security/plugins/org.argeo.security.ui.admin/src/main/java/org/argeo/security/ui/admin/views/UsersView.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.security.ui.admin.views;
  17
  18 import java.util.ArrayList;
  19 import java.util.List;
  20
  21 import javax.jcr.Node;
  22 import javax.jcr.NodeIterator;
  23 import javax.jcr.Property;
  24 import javax.jcr.RepositoryException;
  25 import javax.jcr.Session;
  26 import javax.jcr.observation.Event;
  27 import javax.jcr.observation.EventIterator;
  28 import javax.jcr.observation.EventListener;
  29 import javax.jcr.query.Query;
  30
  31 import org.argeo.ArgeoException;
  32 import org.argeo.eclipse.ui.EclipseUiUtils;
  33 import org.argeo.eclipse.ui.specific.EclipseUiSpecificUtils;
  34 import org.argeo.jcr.ArgeoNames;
  35 import org.argeo.jcr.ArgeoTypes;
  36 import org.argeo.jcr.JcrUtils;
  37 import org.argeo.security.ui.admin.SecurityAdminPlugin;
  38 import org.argeo.security.ui.admin.commands.OpenArgeoUserEditor;
  39 import org.eclipse.core.commands.Command;
  40 import org.eclipse.core.commands.IParameter;
  41 import org.eclipse.core.commands.Parameterization;
  42 import org.eclipse.core.commands.ParameterizedCommand;
  43 import org.eclipse.jface.resource.JFaceResources;
  44 import org.eclipse.jface.viewers.ColumnLabelProvider;
  45 import org.eclipse.jface.viewers.DoubleClickEvent;
  46 import org.eclipse.jface.viewers.IDoubleClickListener;
  47 import org.eclipse.jface.viewers.IStructuredContentProvider;
  48 import org.eclipse.jface.viewers.IStructuredSelection;
  49 import org.eclipse.jface.viewers.TableViewer;
  50 import org.eclipse.jface.viewers.TableViewerColumn;
  51 import org.eclipse.jface.viewers.Viewer;
  52 import org.eclipse.swt.SWT;
  53 import org.eclipse.swt.graphics.Font;
  54 import org.eclipse.swt.widgets.Composite;
  55 import org.eclipse.swt.widgets.Table;
  56 import org.eclipse.ui.IWorkbench;
  57 import org.eclipse.ui.IWorkbenchWindow;
  58 import org.eclipse.ui.commands.ICommandService;
  59 import org.eclipse.ui.handlers.IHandlerService;
  60 import org.eclipse.ui.part.ViewPart;
  61
  62 /** List all users. */
  63 public class UsersView extends ViewPart implements ArgeoNames, ArgeoTypes {
  64         public final static String ID = "org.argeo.security.ui.admin.adminUsersView";
  65
  66         private TableViewer viewer;
  67         private Session session;
  68
  69         private UserStructureListener userStructureListener;
  70
  71         private Font italic;
  72         private Font bold;
  73
  74         @Override
  75         public void createPartControl(Composite parent) {
  76                 italic = EclipseUiUtils.getItalicFont(parent);
  77                 bold = EclipseUiUtils.getBoldFont(parent);
  78
  79                 // viewer = new TableViewer(createTable(parent));
  80                 viewer = createTableViewer(parent);
  81                 EclipseUiSpecificUtils.enableToolTipSupport(viewer);
  82                 viewer.setContentProvider(new UsersContentProvider());
  83                 // viewer.setLabelProvider(new UsersLabelProvider());
  84                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  85                 getViewSite().setSelectionProvider(viewer);
  86                 viewer.setInput(getViewSite());
  87
  88                 userStructureListener = new UserStructureListener();
  89                 JcrUtils.addListener(session, userStructureListener, Event.NODE_ADDED
  90                                 | Event.NODE_REMOVED, JcrUtils.DEFAULT_HOME_BASE_PATH,
  91                                 ArgeoTypes.ARGEO_USER_HOME);
  92         }
  93
  94         protected TableViewer createTableViewer(final Composite parent) {
  95
  96                 Table table = new Table(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  97                 TableViewer viewer = new TableViewer(table);
  98                 table.setLinesVisible(true);
  99                 table.setHeaderVisible(true);
 100
 101                 // User ID
 102                 TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);
 103                 column.getColumn().setText("User ID");
 104                 column.getColumn().setWidth(100);
 105                 column.setLabelProvider(new CLProvider() {
 106                         public String getText(Object elem) {
 107                                 return getProperty(elem, ARGEO_USER_ID);
 108                                 // if (username.equals(session.getUserID()))
 109                                 // return "[" + username + "]";
 110                                 // else
 111                                 // return username;
 112                         }
 113                 });
 114
 115                 // Displayed name
 116                 column = new TableViewerColumn(viewer, SWT.NONE);
 117                 column.getColumn().setText("Name");
 118                 column.getColumn().setWidth(150);
 119                 column.setLabelProvider(new CLProvider() {
 120                         public String getText(Object elem) {
 121                                 return getProperty(elem, Property.JCR_TITLE);
 122                         }
 123                 });
 124
 125                 // E-mail
 126                 column = new TableViewerColumn(viewer, SWT.NONE);
 127                 column.getColumn().setText("E-mail");
 128                 column.getColumn().setWidth(150);
 129                 column.setLabelProvider(new CLProvider() {
 130                         public String getText(Object elem) {
 131                                 return getProperty(elem, ARGEO_PRIMARY_EMAIL);
 132                         }
 133                 });
 134
 135                 // E-mail
 136                 column = new TableViewerColumn(viewer, SWT.NONE);
 137                 column.getColumn().setText("Description");
 138                 column.getColumn().setWidth(200);
 139                 column.setLabelProvider(new CLProvider() {
 140                         public String getText(Object elem) {
 141                                 return getProperty(elem, Property.JCR_DESCRIPTION);
 142                         }
 143                 });
 144
 145                 return viewer;
 146         }
 147
 148         private class CLProvider extends ColumnLabelProvider {
 149
 150                 public String getToolTipText(Object element) {
 151                         return getText(element);
 152                 }
 153
 154                 @Override
 155                 public Font getFont(Object elem) {
 156                         // self
 157                         String username = getProperty(elem, ARGEO_USER_ID);
 158                         if (username.equals(session.getUserID()))
 159                                 return bold;
 160
 161                         // disabled
 162                         try {
 163                                 Node userHome = (Node) elem;
 164                                 Node userProfile = userHome.getNode(ARGEO_PROFILE);
 165                                 if (!userProfile.getProperty(ARGEO_ENABLED).getBoolean())
 166                                         return italic;
 167                                 else
 168                                         return null;
 169                         } catch (RepositoryException e) {
 170                                 throw new ArgeoException("Cannot get font for " + username, e);
 171                         }
 172                 }
 173
 174         }
 175
 176         // protected Table createTable(Composite parent) {
 177         // // TODO use a more flexible API
 178         // Table table = new Table(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
 179         // table.setLinesVisible(true);
 180         // table.setHeaderVisible(true);
 181         // TableColumn column = new TableColumn(table, SWT.LEFT, 0);
 182         // column.setText("Username");
 183         // column.setWidth(100);
 184         // column = new TableColumn(table, SWT.LEFT, 1);
 185         // column.setText("Displayed name");
 186         // column.setWidth(150);
 187         // column = new TableColumn(table, SWT.LEFT, 2);
 188         // column.setText("E-mail");
 189         // column.setWidth(100);
 190         // column = new TableColumn(table, SWT.LEFT, 3);
 191         // column.setText("First Name");
 192         // column.setWidth(100);
 193         // column = new TableColumn(table, SWT.LEFT, 4);
 194         // column.setText("Last Name");
 195         // column.setWidth(100);
 196         // column = new TableColumn(table, SWT.LEFT, 5);
 197         // column.setText("Status");
 198         // column.setWidth(50);
 199         // column = new TableColumn(table, SWT.LEFT, 6);
 200         // column.setText("Description");
 201         // column.setWidth(200);
 202         // return table;
 203         // }
 204
 205         // private class UsersLabelProvider extends LabelProvider implements
 206         // ITableLabelProvider {
 207         // public String getColumnText(Object element, int columnIndex) {
 208         // try {
 209         // Node userHome = (Node) element;
 210         // Node userProfile = userHome.getNode(ARGEO_PROFILE);
 211         // switch (columnIndex) {
 212         // case 0:
 213         // String username = userHome.getProperty(ARGEO_USER_ID)
 214         // .getString();
 215         // if (username.equals(session.getUserID()))
 216         // return "[" + username + "]";
 217         // else
 218         // return username;
 219         // case 1:
 220         // return getProperty(userProfile, Property.JCR_TITLE);
 221         // case 2:
 222         // return getProperty(userProfile, ARGEO_PRIMARY_EMAIL);
 223         // case 3:
 224         // return getProperty(userProfile, ARGEO_FIRST_NAME);
 225         // case 4:
 226         // return getProperty(userProfile, ARGEO_LAST_NAME);
 227         // case 5:
 228         // return userProfile.getProperty(ARGEO_ENABLED).getBoolean() ? ""
 229         // : "disabled";
 230         // case 6:
 231         // return getProperty(userProfile, Property.JCR_DESCRIPTION);
 232         // default:
 233         // throw new ArgeoException("Unmanaged column " + columnIndex);
 234         // }
 235         // } catch (RepositoryException e) {
 236         // throw new ArgeoException("Cannot get text", e);
 237         // }
 238         // }
 239         //
 240         // public Image getColumnImage(Object element, int columnIndex) {
 241         // return null;
 242         // }
 243         //
 244         // }
 245
 246         @Override
 247         public void setFocus() {
 248                 viewer.getTable().setFocus();
 249         }
 250
 251         @Override
 252         public void dispose() {
 253                 JcrUtils.removeListenerQuietly(session, userStructureListener);
 254                 super.dispose();
 255         }
 256
 257         public void setSession(Session session) {
 258                 this.session = session;
 259         }
 260
 261         public void refresh() {
 262                 viewer.refresh();
 263         }
 264
 265         protected String getProperty(Node userProfile, String name)
 266                         throws RepositoryException {
 267                 return userProfile.hasProperty(name) ? userProfile.getProperty(name)
 268                                 .getString() : "";
 269         }
 270
 271         protected String getProperty(Object element, String name) {
 272                 try {
 273                         Node userHome = (Node) element;
 274                         Node userProfile = userHome.getNode(ARGEO_PROFILE);
 275                         return userProfile.hasProperty(name) ? userProfile
 276                                         .getProperty(name).getString() : "";
 277                 } catch (RepositoryException e) {
 278                         throw new ArgeoException("Cannot get property " + name, e);
 279                 }
 280         }
 281
 282         private class UserStructureListener implements EventListener {
 283
 284                 @Override
 285                 public void onEvent(EventIterator events) {
 286                         viewer.refresh();
 287                 }
 288         }
 289
 290         private class UsersContentProvider implements IStructuredContentProvider {
 291
 292                 public Object[] getElements(Object inputElement) {
 293                         try {
 294                                 Query query = session
 295                                                 .getWorkspace()
 296                                                 .getQueryManager()
 297                                                 .createQuery(
 298                                                                 "select [" + ARGEO_PROFILE + "] from ["
 299                                                                                 + ARGEO_USER_HOME + "]", Query.JCR_SQL2);
 300                                 NodeIterator nit = query.execute().getNodes();
 301                                 List<Node> userProfiles = new ArrayList<Node>();
 302                                 while (nit.hasNext()) {
 303                                         userProfiles.add(nit.nextNode());
 304                                 }
 305                                 return userProfiles.toArray();
 306                         } catch (RepositoryException e) {
 307                                 throw new ArgeoException("Cannot list users", e);
 308                         }
 309                         // return userAdminService.listUsers().toArray();
 310                 }
 311
 312                 public void dispose() {
 313                 }
 314
 315                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 316                 }
 317
 318         }
 319
 320         class ViewDoubleClickListener implements IDoubleClickListener {
 321                 public void doubleClick(DoubleClickEvent evt) {
 322                         if (evt.getSelection().isEmpty())
 323                                 return;
 324
 325                         Object obj = ((IStructuredSelection) evt.getSelection())
 326                                         .getFirstElement();
 327                         if (obj instanceof Node) {
 328                                 IWorkbench iw = SecurityAdminPlugin.getDefault().getWorkbench();
 329                                 IHandlerService handlerService = (IHandlerService) iw
 330                                                 .getService(IHandlerService.class);
 331                                 try {
 332                                         String username = ((Node) obj).getProperty(ARGEO_USER_ID)
 333                                                         .getString();
 334                                         String commandId = OpenArgeoUserEditor.COMMAND_ID;
 335                                         String paramName = OpenArgeoUserEditor.PARAM_USERNAME;
 336
 337                                         // TODO: factorize this
 338                                         // execute related command
 339                                         IWorkbenchWindow window = iw.getActiveWorkbenchWindow();
 340                                         ICommandService cmdService = (ICommandService) window
 341                                                         .getService(ICommandService.class);
 342                                         Command cmd = cmdService.getCommand(commandId);
 343                                         ArrayList<Parameterization> parameters = new ArrayList<Parameterization>();
 344                                         IParameter iparam = cmd.getParameter(paramName);
 345                                         Parameterization param = new Parameterization(iparam,
 346                                                         username);
 347                                         parameters.add(param);
 348                                         ParameterizedCommand pc = new ParameterizedCommand(cmd,
 349                                                         parameters.toArray(new Parameterization[parameters
 350                                                                         .size()]));
 351                                         handlerService = (IHandlerService) window
 352                                                         .getService(IHandlerService.class);
 353                                         handlerService.executeCommand(pc, null);
 354                                 } catch (Exception e) {
 355                                         throw new ArgeoException("Cannot open editor", e);
 356                                 }
 357
 358                         }
 359                 }
 360         }
 361
 362 }