security/plugins/org.argeo.security.ui.admin/src/main/java/org/argeo/security/ui/admin/views/UsersView.java

   1 /*
   2  * Copyright (C) 2007-2012 Argeo GmbH
   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.ArgeoJcrConstants;
  35 import org.argeo.jcr.ArgeoNames;
  36 import org.argeo.jcr.ArgeoTypes;
  37 import org.argeo.jcr.JcrUtils;
  38 import org.argeo.security.ui.admin.SecurityAdminPlugin;
  39 import org.argeo.security.ui.admin.commands.OpenArgeoUserEditor;
  40 import org.eclipse.core.commands.Command;
  41 import org.eclipse.core.commands.IParameter;
  42 import org.eclipse.core.commands.Parameterization;
  43 import org.eclipse.core.commands.ParameterizedCommand;
  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 {
  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         private UserPropertiesListener userPropertiesListener;
  71
  72         private Font italic;
  73         private Font bold;
  74
  75         @Override
  76         public void createPartControl(Composite parent) {
  77                 italic = EclipseUiUtils.getItalicFont(parent);
  78                 bold = EclipseUiUtils.getBoldFont(parent);
  79
  80                 // viewer = new TableViewer(createTable(parent));
  81                 viewer = createTableViewer(parent);
  82                 EclipseUiSpecificUtils.enableToolTipSupport(viewer);
  83                 viewer.setContentProvider(new UsersContentProvider());
  84                 // viewer.setLabelProvider(new UsersLabelProvider());
  85                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  86                 getViewSite().setSelectionProvider(viewer);
  87                 viewer.setInput(getViewSite());
  88
  89                 userStructureListener = new UserStructureListener();
  90                 JcrUtils.addListener(session, userStructureListener, Event.NODE_ADDED
  91                                 | Event.NODE_REMOVED, ArgeoJcrConstants.PEOPLE_BASE_PATH, null);
  92                 userPropertiesListener = new UserPropertiesListener();
  93                 JcrUtils.addListener(session, userStructureListener,
  94                                 Event.PROPERTY_CHANGED | Event.PROPERTY_ADDED
  95                                                 | Event.PROPERTY_REMOVED,
  96                                 ArgeoJcrConstants.PEOPLE_BASE_PATH,
  97                                 ArgeoTypes.ARGEO_USER_PROFILE);
  98         }
  99
 100         protected TableViewer createTableViewer(final Composite parent) {
 101
 102                 Table table = new Table(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
 103                 TableViewer viewer = new TableViewer(table);
 104                 table.setLinesVisible(true);
 105                 table.setHeaderVisible(true);
 106
 107                 // User ID
 108                 TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);
 109                 column.getColumn().setText("User ID");
 110                 column.getColumn().setWidth(100);
 111                 column.setLabelProvider(new CLProvider() {
 112                         public String getText(Object elem) {
 113                                 return getProperty(elem, ARGEO_USER_ID);
 114                                 // if (username.equals(session.getUserID()))
 115                                 // return "[" + username + "]";
 116                                 // else
 117                                 // return username;
 118                         }
 119                 });
 120
 121                 // Displayed name
 122                 column = new TableViewerColumn(viewer, SWT.NONE);
 123                 column.getColumn().setText("Name");
 124                 column.getColumn().setWidth(150);
 125                 column.setLabelProvider(new CLProvider() {
 126                         public String getText(Object elem) {
 127                                 return getProperty(elem, Property.JCR_TITLE);
 128                         }
 129                 });
 130
 131                 // E-mail
 132                 column = new TableViewerColumn(viewer, SWT.NONE);
 133                 column.getColumn().setText("E-mail");
 134                 column.getColumn().setWidth(150);
 135                 column.setLabelProvider(new CLProvider() {
 136                         public String getText(Object elem) {
 137                                 return getProperty(elem, ARGEO_PRIMARY_EMAIL);
 138                         }
 139                 });
 140
 141                 // E-mail
 142                 column = new TableViewerColumn(viewer, SWT.NONE);
 143                 column.getColumn().setText("Description");
 144                 column.getColumn().setWidth(200);
 145                 column.setLabelProvider(new CLProvider() {
 146                         public String getText(Object elem) {
 147                                 return getProperty(elem, Property.JCR_DESCRIPTION);
 148                         }
 149                 });
 150
 151                 return viewer;
 152         }
 153
 154         private class CLProvider extends ColumnLabelProvider {
 155
 156                 public String getToolTipText(Object element) {
 157                         return getText(element);
 158                 }
 159
 160                 @Override
 161                 public Font getFont(Object elem) {
 162                         // self
 163                         String username = getProperty(elem, ARGEO_USER_ID);
 164                         if (username.equals(session.getUserID()))
 165                                 return bold;
 166
 167                         // disabled
 168                         try {
 169                                 Node userProfile = (Node) elem;
 170                                 // Node userProfile = userHome.getNode(ARGEO_PROFILE);
 171                                 if (!userProfile.getProperty(ARGEO_ENABLED).getBoolean())
 172                                         return italic;
 173                                 else
 174                                         return null;
 175                         } catch (RepositoryException e) {
 176                                 throw new ArgeoException("Cannot get font for " + username, e);
 177                         }
 178                 }
 179
 180         }
 181
 182         @Override
 183         public void setFocus() {
 184                 viewer.getTable().setFocus();
 185         }
 186
 187         @Override
 188         public void dispose() {
 189                 JcrUtils.removeListenerQuietly(session, userStructureListener);
 190                 JcrUtils.removeListenerQuietly(session, userPropertiesListener);
 191                 super.dispose();
 192         }
 193
 194         public void setSession(Session session) {
 195                 this.session = session;
 196         }
 197
 198         public void refresh() {
 199                 viewer.refresh();
 200         }
 201
 202         protected String getProperty(Node userProfile, String name)
 203                         throws RepositoryException {
 204                 return userProfile.hasProperty(name) ? userProfile.getProperty(name)
 205                                 .getString() : "";
 206         }
 207
 208         protected String getProperty(Object element, String name) {
 209                 try {
 210                         Node userProfile = (Node) element;
 211                         // Node userProfile = userHome.getNode(ARGEO_PROFILE);
 212                         return userProfile.hasProperty(name) ? userProfile
 213                                         .getProperty(name).getString() : "";
 214                 } catch (RepositoryException e) {
 215                         throw new ArgeoException("Cannot get property " + name, e);
 216                 }
 217         }
 218
 219         private class UserStructureListener implements EventListener {
 220
 221                 @Override
 222                 public void onEvent(EventIterator events) {
 223                         viewer.refresh();
 224                 }
 225         }
 226
 227         private class UserPropertiesListener implements EventListener {
 228
 229                 @Override
 230                 public void onEvent(EventIterator events) {
 231                         viewer.refresh();
 232                 }
 233         }
 234
 235         private class UsersContentProvider implements IStructuredContentProvider {
 236
 237                 public Object[] getElements(Object inputElement) {
 238                         try {
 239                                 Query query = session
 240                                                 .getWorkspace()
 241                                                 .getQueryManager()
 242                                                 .createQuery(
 243                                                                 "select * from ["
 244                                                                                 + ArgeoTypes.ARGEO_USER_PROFILE + "]",
 245                                                                 Query.JCR_SQL2);
 246                                 NodeIterator nit = query.execute().getNodes();
 247                                 List<Node> userProfiles = new ArrayList<Node>();
 248                                 while (nit.hasNext()) {
 249                                         userProfiles.add(nit.nextNode());
 250                                 }
 251                                 return userProfiles.toArray();
 252                         } catch (RepositoryException e) {
 253                                 throw new ArgeoException("Cannot list users", e);
 254                         }
 255                         // return userAdminService.listUsers().toArray();
 256                 }
 257
 258                 public void dispose() {
 259                 }
 260
 261                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 262                 }
 263
 264         }
 265
 266         class ViewDoubleClickListener implements IDoubleClickListener {
 267                 public void doubleClick(DoubleClickEvent evt) {
 268                         if (evt.getSelection().isEmpty())
 269                                 return;
 270
 271                         Object obj = ((IStructuredSelection) evt.getSelection())
 272                                         .getFirstElement();
 273                         if (obj instanceof Node) {
 274                                 IWorkbench iw = SecurityAdminPlugin.getDefault().getWorkbench();
 275                                 IHandlerService handlerService = (IHandlerService) iw
 276                                                 .getService(IHandlerService.class);
 277                                 try {
 278                                         String username = ((Node) obj).getProperty(ARGEO_USER_ID)
 279                                                         .getString();
 280                                         String commandId = OpenArgeoUserEditor.COMMAND_ID;
 281                                         String paramName = OpenArgeoUserEditor.PARAM_USERNAME;
 282
 283                                         // TODO: factorize this
 284                                         // execute related command
 285                                         IWorkbenchWindow window = iw.getActiveWorkbenchWindow();
 286                                         ICommandService cmdService = (ICommandService) window
 287                                                         .getService(ICommandService.class);
 288                                         Command cmd = cmdService.getCommand(commandId);
 289                                         ArrayList<Parameterization> parameters = new ArrayList<Parameterization>();
 290                                         IParameter iparam = cmd.getParameter(paramName);
 291                                         Parameterization param = new Parameterization(iparam,
 292                                                         username);
 293                                         parameters.add(param);
 294                                         ParameterizedCommand pc = new ParameterizedCommand(cmd,
 295                                                         parameters.toArray(new Parameterization[parameters
 296                                                                         .size()]));
 297                                         handlerService = (IHandlerService) window
 298                                                         .getService(IHandlerService.class);
 299                                         handlerService.executeCommand(pc, null);
 300                                 } catch (Exception e) {
 301                                         throw new ArgeoException("Cannot open editor", e);
 302                                 }
 303
 304                         }
 305                 }
 306         }
 307
 308 }