UsersView.java

   1 package org.argeo.security.ui.admin.views;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import javax.jcr.Node;
   7 import javax.jcr.NodeIterator;
   8 import javax.jcr.RepositoryException;
   9 import javax.jcr.Session;
  10 import javax.jcr.observation.EventIterator;
  11 import javax.jcr.observation.EventListener;
  12 import javax.jcr.query.Query;
  13
  14 import org.argeo.ArgeoException;
  15 import org.argeo.jcr.ArgeoNames;
  16 import org.argeo.jcr.ArgeoTypes;
  17 import org.argeo.security.ui.admin.SecurityAdminPlugin;
  18 import org.argeo.security.ui.admin.commands.OpenArgeoUserEditor;
  19 import org.eclipse.core.commands.Command;
  20 import org.eclipse.core.commands.IParameter;
  21 import org.eclipse.core.commands.Parameterization;
  22 import org.eclipse.core.commands.ParameterizedCommand;
  23 import org.eclipse.jface.viewers.DoubleClickEvent;
  24 import org.eclipse.jface.viewers.IDoubleClickListener;
  25 import org.eclipse.jface.viewers.IStructuredContentProvider;
  26 import org.eclipse.jface.viewers.IStructuredSelection;
  27 import org.eclipse.jface.viewers.ITableLabelProvider;
  28 import org.eclipse.jface.viewers.LabelProvider;
  29 import org.eclipse.jface.viewers.TableViewer;
  30 import org.eclipse.jface.viewers.Viewer;
  31 import org.eclipse.swt.SWT;
  32 import org.eclipse.swt.graphics.Image;
  33 import org.eclipse.swt.widgets.Composite;
  34 import org.eclipse.swt.widgets.Table;
  35 import org.eclipse.swt.widgets.TableColumn;
  36 import org.eclipse.ui.IWorkbench;
  37 import org.eclipse.ui.IWorkbenchWindow;
  38 import org.eclipse.ui.commands.ICommandService;
  39 import org.eclipse.ui.handlers.IHandlerService;
  40 import org.eclipse.ui.part.ViewPart;
  41
  42 /** List all users. */
  43 public class UsersView extends ViewPart implements ArgeoNames, ArgeoTypes,
  44                 EventListener {
  45         public final static String ID = "org.argeo.security.ui.admin.adminUsersView";
  46
  47         private TableViewer viewer;
  48         private Session session;
  49
  50         @Override
  51         public void createPartControl(Composite parent) {
  52                 viewer = new TableViewer(createTable(parent));
  53                 viewer.setContentProvider(new UsersContentProvider());
  54                 viewer.setLabelProvider(new UsersLabelProvider());
  55                 viewer.addDoubleClickListener(new ViewDoubleClickListener());
  56                 viewer.setInput(getViewSite());
  57         }
  58
  59         protected Table createTable(Composite parent) {
  60                 Table table = new Table(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  61                 table.setLinesVisible(true);
  62                 table.setHeaderVisible(true);
  63                 TableColumn column = new TableColumn(table, SWT.LEFT, 0);
  64                 column.setText("User");
  65                 column.setWidth(50);
  66                 column = new TableColumn(table, SWT.LEFT, 1);
  67                 column.setText("First Name");
  68                 column.setWidth(100);
  69                 column = new TableColumn(table, SWT.LEFT, 2);
  70                 column.setText("Last Name");
  71                 column.setWidth(100);
  72                 column = new TableColumn(table, SWT.LEFT, 3);
  73                 column.setText("E-mail");
  74                 column.setWidth(100);
  75                 return table;
  76         }
  77
  78         @Override
  79         public void setFocus() {
  80                 viewer.getTable().setFocus();
  81         }
  82
  83         public void setSession(Session session) {
  84                 this.session = session;
  85         }
  86
  87         public void refresh() {
  88                 viewer.refresh();
  89         }
  90
  91         @Override
  92         public void onEvent(EventIterator events) {
  93                 viewer.refresh();
  94         }
  95
  96         private class UsersContentProvider implements IStructuredContentProvider {
  97
  98                 public Object[] getElements(Object inputElement) {
  99                         try {
 100                                 Query query = session
 101                                                 .getWorkspace()
 102                                                 .getQueryManager()
 103                                                 .createQuery(
 104                                                                 "select [" + ARGEO_PROFILE + "] from ["
 105                                                                                 + ARGEO_USER_HOME + "]", Query.JCR_SQL2);
 106                                 NodeIterator nit = query.execute().getNodes();
 107                                 List<Node> userProfiles = new ArrayList<Node>();
 108                                 while (nit.hasNext()) {
 109                                         userProfiles.add(nit.nextNode());
 110                                 }
 111                                 return userProfiles.toArray();
 112                         } catch (RepositoryException e) {
 113                                 throw new ArgeoException("Cannot list users", e);
 114                         }
 115                         // return userAdminService.listUsers().toArray();
 116                 }
 117
 118                 public void dispose() {
 119                 }
 120
 121                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 122                 }
 123
 124         }
 125
 126         private class UsersLabelProvider extends LabelProvider implements
 127                         ITableLabelProvider {
 128                 public String getColumnText(Object element, int columnIndex) {
 129                         try {
 130                                 Node userHome = (Node) element;
 131                                 switch (columnIndex) {
 132                                 case 0:
 133                                         String userName = userHome.getProperty(ARGEO_USER_ID)
 134                                                         .getString();
 135                                         if (userName.equals(session.getUserID()))
 136                                                 return "[" + userName + "]";
 137                                         else
 138                                                 return userName;
 139                                 case 1:
 140                                         return userHome.getNode(ARGEO_PROFILE)
 141                                                         .getProperty(ARGEO_FIRST_NAME).getString();
 142                                 case 2:
 143                                         return userHome.getNode(ARGEO_PROFILE)
 144                                                         .getProperty(ARGEO_LAST_NAME).getString();
 145                                 case 3:
 146                                         return userHome.getNode(ARGEO_PROFILE)
 147                                                         .getProperty(ARGEO_PRIMARY_EMAIL).getString();
 148                                 default:
 149                                         throw new ArgeoException("Unmanaged column " + columnIndex);
 150                                 }
 151                         } catch (RepositoryException e) {
 152                                 throw new ArgeoException("Cannot get text", e);
 153                         }
 154                 }
 155
 156                 public Image getColumnImage(Object element, int columnIndex) {
 157                         return null;
 158                 }
 159
 160         }
 161
 162         class ViewDoubleClickListener implements IDoubleClickListener {
 163                 public void doubleClick(DoubleClickEvent evt) {
 164                         if (evt.getSelection().isEmpty())
 165                                 return;
 166
 167                         Object obj = ((IStructuredSelection) evt.getSelection())
 168                                         .getFirstElement();
 169                         if (obj instanceof Node) {
 170                                 IWorkbench iw = SecurityAdminPlugin.getDefault().getWorkbench();
 171                                 IHandlerService handlerService = (IHandlerService) iw
 172                                                 .getService(IHandlerService.class);
 173                                 try {
 174                                         String username = ((Node) obj).getProperty(ARGEO_USER_ID)
 175                                                         .getString();
 176                                         String commandId = OpenArgeoUserEditor.COMMAND_ID;
 177                                         String paramName = OpenArgeoUserEditor.PARAM_USERNAME;
 178
 179                                         // TODO: factorize this
 180                                         // execute related command
 181                                         IWorkbenchWindow window = iw.getActiveWorkbenchWindow();
 182                                         ICommandService cmdService = (ICommandService) window
 183                                                         .getService(ICommandService.class);
 184                                         Command cmd = cmdService.getCommand(commandId);
 185                                         ArrayList<Parameterization> parameters = new ArrayList<Parameterization>();
 186                                         IParameter iparam = cmd.getParameter(paramName);
 187                                         Parameterization param = new Parameterization(iparam,
 188                                                         username);
 189                                         parameters.add(param);
 190                                         ParameterizedCommand pc = new ParameterizedCommand(cmd,
 191                                                         parameters.toArray(new Parameterization[parameters
 192                                                                         .size()]));
 193                                         handlerService = (IHandlerService) window
 194                                                         .getService(IHandlerService.class);
 195                                         handlerService.executeCommand(pc, null);
 196                                 } catch (Exception e) {
 197                                         throw new ArgeoException("Cannot open editor", e);
 198                                 }
 199
 200                         }
 201                 }
 202         }
 203
 204 }