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