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                 getViewSite().setSelectionProvider(viewer);
  57                 viewer.setInput(getViewSite());
  58         }
  59
  60         protected Table createTable(Composite parent) {
  61                 Table table = new Table(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  62                 table.setLinesVisible(true);
  63                 table.setHeaderVisible(true);
  64                 TableColumn column = new TableColumn(table, SWT.LEFT, 0);
  65                 column.setText("User");
  66                 column.setWidth(50);
  67                 column = new TableColumn(table, SWT.LEFT, 1);
  68                 column.setText("First Name");
  69                 column.setWidth(100);
  70                 column = new TableColumn(table, SWT.LEFT, 2);
  71                 column.setText("Last Name");
  72                 column.setWidth(100);
  73                 column = new TableColumn(table, SWT.LEFT, 3);
  74                 column.setText("E-mail");
  75                 column.setWidth(100);
  76                 return table;
  77         }
  78
  79         @Override
  80         public void setFocus() {
  81                 viewer.getTable().setFocus();
  82         }
  83
  84         public void setSession(Session session) {
  85                 this.session = session;
  86         }
  87
  88         public void refresh() {
  89                 viewer.refresh();
  90         }
  91
  92         @Override
  93         public void onEvent(EventIterator events) {
  94                 viewer.refresh();
  95         }
  96
  97         private class UsersContentProvider implements IStructuredContentProvider {
  98
  99                 public Object[] getElements(Object inputElement) {
 100                         try {
 101                                 Query query = session
 102                                                 .getWorkspace()
 103                                                 .getQueryManager()
 104                                                 .createQuery(
 105                                                                 "select [" + ARGEO_PROFILE + "] from ["
 106                                                                                 + ARGEO_USER_HOME + "]", Query.JCR_SQL2);
 107                                 NodeIterator nit = query.execute().getNodes();
 108                                 List<Node> userProfiles = new ArrayList<Node>();
 109                                 while (nit.hasNext()) {
 110                                         userProfiles.add(nit.nextNode());
 111                                 }
 112                                 return userProfiles.toArray();
 113                         } catch (RepositoryException e) {
 114                                 throw new ArgeoException("Cannot list users", e);
 115                         }
 116                         // return userAdminService.listUsers().toArray();
 117                 }
 118
 119                 public void dispose() {
 120                 }
 121
 122                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 123                 }
 124
 125         }
 126
 127         private class UsersLabelProvider extends LabelProvider implements
 128                         ITableLabelProvider {
 129                 public String getColumnText(Object element, int columnIndex) {
 130                         try {
 131                                 Node userHome = (Node) element;
 132                                 Node userProfile = userHome.getNode(ARGEO_PROFILE);
 133                                 switch (columnIndex) {
 134                                 case 0:
 135                                         String userName = userHome.getProperty(ARGEO_USER_ID)
 136                                                         .getString();
 137                                         if (userName.equals(session.getUserID()))
 138                                                 return "[" + userName + "]";
 139                                         else
 140                                                 return userName;
 141                                 case 1:
 142                                         return userProfile.hasProperty(ARGEO_FIRST_NAME) ? userProfile
 143                                                         .getProperty(ARGEO_FIRST_NAME).getString() : "";
 144                                 case 2:
 145                                         return userProfile.hasProperty(ARGEO_LAST_NAME) ? userProfile
 146                                                         .getProperty(ARGEO_LAST_NAME).getString() : "";
 147                                 case 3:
 148                                         return userProfile.hasProperty(ARGEO_PRIMARY_EMAIL) ? userProfile
 149                                                         .getProperty(ARGEO_PRIMARY_EMAIL).getString() : "";
 150                                 default:
 151                                         throw new ArgeoException("Unmanaged column " + columnIndex);
 152                                 }
 153                         } catch (RepositoryException e) {
 154                                 throw new ArgeoException("Cannot get text", e);
 155                         }
 156                 }
 157
 158                 public Image getColumnImage(Object element, int columnIndex) {
 159                         return null;
 160                 }
 161
 162         }
 163
 164         class ViewDoubleClickListener implements IDoubleClickListener {
 165                 public void doubleClick(DoubleClickEvent evt) {
 166                         if (evt.getSelection().isEmpty())
 167                                 return;
 168
 169                         Object obj = ((IStructuredSelection) evt.getSelection())
 170                                         .getFirstElement();
 171                         if (obj instanceof Node) {
 172                                 IWorkbench iw = SecurityAdminPlugin.getDefault().getWorkbench();
 173                                 IHandlerService handlerService = (IHandlerService) iw
 174                                                 .getService(IHandlerService.class);
 175                                 try {
 176                                         String username = ((Node) obj).getProperty(ARGEO_USER_ID)
 177                                                         .getString();
 178                                         String commandId = OpenArgeoUserEditor.COMMAND_ID;
 179                                         String paramName = OpenArgeoUserEditor.PARAM_USERNAME;
 180
 181                                         // TODO: factorize this
 182                                         // execute related command
 183                                         IWorkbenchWindow window = iw.getActiveWorkbenchWindow();
 184                                         ICommandService cmdService = (ICommandService) window
 185                                                         .getService(ICommandService.class);
 186                                         Command cmd = cmdService.getCommand(commandId);
 187                                         ArrayList<Parameterization> parameters = new ArrayList<Parameterization>();
 188                                         IParameter iparam = cmd.getParameter(paramName);
 189                                         Parameterization param = new Parameterization(iparam,
 190                                                         username);
 191                                         parameters.add(param);
 192                                         ParameterizedCommand pc = new ParameterizedCommand(cmd,
 193                                                         parameters.toArray(new Parameterization[parameters
 194                                                                         .size()]));
 195                                         handlerService = (IHandlerService) window
 196                                                         .getService(IHandlerService.class);
 197                                         handlerService.executeCommand(pc, null);
 198                                 } catch (Exception e) {
 199                                         throw new ArgeoException("Cannot open editor", e);
 200                                 }
 201
 202                         }
 203                 }
 204         }
 205
 206 }