Users.java

   1 package org.argeo.cms.users;
   2
   3 import java.util.Iterator;
   4 import java.util.Map;
   5 import java.util.TreeMap;
   6
   7 import javax.jcr.Node;
   8 import javax.jcr.RepositoryException;
   9 import javax.jcr.Session;
  10 import javax.jcr.security.AccessControlManager;
  11 import javax.jcr.security.Privilege;
  12
  13 import org.apache.commons.logging.Log;
  14 import org.apache.commons.logging.LogFactory;
  15 import org.argeo.ArgeoException;
  16 import org.argeo.cms.CmsUiProvider;
  17 import org.argeo.cms.CmsUtils;
  18 import org.argeo.cms.maintenance.NonAdminPage;
  19 import org.argeo.eclipse.ui.dialogs.UserCreationWizard;
  20 import org.argeo.eclipse.ui.parts.UsersTable;
  21 import org.argeo.jcr.ArgeoNames;
  22 import org.argeo.jcr.JcrUtils;
  23 import org.argeo.security.UserAdminService;
  24 import org.argeo.security.jcr.JcrSecurityModel;
  25 import org.eclipse.jface.dialogs.Dialog;
  26 import org.eclipse.jface.dialogs.MessageDialog;
  27 import org.eclipse.jface.viewers.ISelection;
  28 import org.eclipse.jface.viewers.ISelectionChangedListener;
  29 import org.eclipse.jface.viewers.IStructuredSelection;
  30 import org.eclipse.jface.viewers.SelectionChangedEvent;
  31 import org.eclipse.jface.viewers.TableViewer;
  32 import org.eclipse.jface.wizard.WizardDialog;
  33 import org.eclipse.swt.SWT;
  34 import org.eclipse.swt.events.DisposeEvent;
  35 import org.eclipse.swt.events.DisposeListener;
  36 import org.eclipse.swt.events.SelectionAdapter;
  37 import org.eclipse.swt.events.SelectionEvent;
  38 import org.eclipse.swt.layout.GridData;
  39 import org.eclipse.swt.layout.GridLayout;
  40 import org.eclipse.swt.widgets.Button;
  41 import org.eclipse.swt.widgets.Composite;
  42 import org.eclipse.swt.widgets.Control;
  43 import org.springframework.security.provisioning.UserDetailsManager;
  44
  45 /**
  46  * Simple page to manage users of a given repository. We still rely on Argeo
  47  * model; with user stored in the main workspace
  48  */
  49 public class Users implements CmsUiProvider {
  50
  51         private final static Log log = LogFactory.getLog(Users.class);
  52
  53         // Enable user CRUD // INJECTED
  54         private UserAdminService userAdminService;
  55         private JcrSecurityModel jcrSecurityModel;
  56         // private UserDetailsManager userDetailsManager;
  57         private String userWkspName;
  58
  59         // Local UI Providers
  60         NonAdminPage nap = new NonAdminPage();
  61         UserPage userPage = new UserPage();
  62
  63         // Manage authorization
  64         @Override
  65         public Control createUi(Composite parent, Node context)
  66                         throws RepositoryException {
  67                 if (isAdmin(context)) {
  68                         Session session = context.getSession().getRepository()
  69                                         .login(userWkspName);
  70                         return createMainLayout(parent, session);
  71                 } else
  72                         nap.createUi(parent, context);
  73                 return null;
  74         }
  75
  76         // Main layout
  77         // Left: User Table - Right User Details Edition
  78         private Control createMainLayout(Composite parent, final Session session)
  79                         throws RepositoryException {
  80
  81                 Composite layoutCmp = new Composite(parent, SWT.NO_FOCUS);
  82                 layoutCmp.setLayoutData(CmsUtils.fillAll());
  83                 layoutCmp
  84                                 .setLayout(CmsUtils.noSpaceGridLayout(new GridLayout(2, true)));
  85
  86                 Composite left = new Composite(layoutCmp, SWT.NO_FOCUS);
  87                 left.setLayoutData(CmsUtils.fillAll());
  88                 UsersTable table = createUsersTable(left, session);
  89
  90                 final Composite right = new Composite(layoutCmp, SWT.NO_FOCUS);
  91                 right.setLayoutData(CmsUtils.fillAll());
  92                 // Composite innerPage = createUserPage(right);
  93                 // final UserViewerOld userViewer = new UserViewerOld(innerPage);
  94
  95                 final TableViewer viewer = table.getTableViewer();
  96                 viewer.addSelectionChangedListener(new ISelectionChangedListener() {
  97
  98                         @Override
  99                         public void selectionChanged(SelectionChangedEvent event) {
 100                                 IStructuredSelection selection = (IStructuredSelection) viewer
 101                                                 .getSelection();
 102                                 if (selection.isEmpty()) {
 103                                         // Should we clean the right column?
 104                                         return;
 105                                 } else {
 106                                         Node context = (Node) selection.getFirstElement();
 107                                         try {
 108                                                 CmsUtils.clear(right);
 109                                                 userPage.createUi(right, context);
 110                                                 right.layout();
 111                                                 right.getParent().layout();
 112                                         } catch (RepositoryException e) {
 113                                                 e.printStackTrace();
 114                                                 throw new ArgeoException("unable to create "
 115                                                                 + "editor for user " + context, e);
 116                                         }
 117                                 }
 118                         }
 119                 });
 120                 return left;
 121         }
 122
 123         private UsersTable createUsersTable(Composite parent, final Session session)
 124                         throws RepositoryException {
 125                 parent.setLayout(CmsUtils.noSpaceGridLayout());
 126
 127                 // Add user CRUD buttons
 128                 Composite buttonCmp = new Composite(parent, SWT.NO_FOCUS);
 129                 buttonCmp.setLayoutData(CmsUtils.fillWidth());
 130                 buttonCmp.setLayout(new GridLayout(2, false));
 131                 // Delete
 132                 final Button deleteBtn = new Button(buttonCmp, SWT.PUSH);
 133                 deleteBtn.setText("Delete selected");
 134                 deleteBtn
 135                                 .setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, true, false));
 136
 137                 // Add
 138                 final Button addBtn = new Button(buttonCmp, SWT.PUSH);
 139                 addBtn.setText("Create");
 140
 141                 // Create the composite that displays the list and a filter
 142                 final UsersTable userTableCmp = new UsersTable(parent, SWT.NO_FOCUS,
 143                                 session);
 144                 userTableCmp.populate(true, false);
 145                 userTableCmp.setLayoutData(CmsUtils.fillAll());
 146
 147                 // The various listeners
 148                 userTableCmp.addDisposeListener(new DisposeListener() {
 149                         private static final long serialVersionUID = -8854052549807709846L;
 150
 151                         @Override
 152                         public void widgetDisposed(DisposeEvent event) {
 153                                 JcrUtils.logoutQuietly(session);
 154                         }
 155                 });
 156
 157                 deleteBtn.addSelectionListener(new SelectionAdapter() {
 158                         private static final long serialVersionUID = -7340611909297995666L;
 159
 160                         @Override
 161                         public void widgetSelected(SelectionEvent e) {
 162
 163                                 TableViewer viewer = userTableCmp.getTableViewer();
 164                                 ISelection selection = viewer.getSelection();
 165                                 if (selection.isEmpty())
 166                                         return;
 167
 168                                 Map<String, Node> toDelete = new TreeMap<String, Node>();
 169                                 @SuppressWarnings("unchecked")
 170                                 Iterator<Node> it = ((IStructuredSelection) selection)
 171                                                 .iterator();
 172                                 nodes: while (it.hasNext()) {
 173                                         Node profileNode = it.next();
 174                                         try {
 175                                                 String userName = profileNode.getProperty(
 176                                                                 ArgeoNames.ARGEO_USER_ID).getString();
 177                                                 if (userName.equals(profileNode.getSession()
 178                                                                 .getUserID())) {
 179                                                         log.warn("Cannot delete its own user: " + userName);
 180                                                         continue nodes;
 181                                                 }
 182                                                 toDelete.put(userName, profileNode);
 183                                         } catch (RepositoryException re) {
 184                                                 log.warn("Cannot interpred user " + profileNode);
 185                                         }
 186                                 }
 187
 188                                 if (!MessageDialog.openQuestion(
 189                                                 userTableCmp.getShell(),
 190                                                 "Delete User",
 191                                                 "Are you sure that you want to delete users "
 192                                                                 + toDelete.keySet()
 193                                                                 + "?\n"
 194                                                                 + "This may lead to inconsistencies in the application."))
 195                                         return;
 196
 197                                 for (String username : toDelete.keySet()) {
 198                                         Session session = null;
 199                                         try {
 200                                                 Node profileNode = toDelete.get(username);
 201                                                 userAdminService.deleteUser(username);
 202                                                 profileNode.getParent().remove();
 203                                                 session = profileNode.getSession();
 204                                                 session.save();
 205                                         } catch (RepositoryException re) {
 206                                                 JcrUtils.discardQuietly(session);
 207                                                 throw new ArgeoException("Cannot list users", re);
 208                                         }
 209                                 }
 210                                 userTableCmp.refresh();
 211                         }
 212                 });
 213
 214                 addBtn.addSelectionListener(new SelectionAdapter() {
 215                         private static final long serialVersionUID = 9214984636836267786L;
 216
 217                         @Override
 218                         public void widgetSelected(SelectionEvent e) {
 219                                 UserCreationWizard newUserWizard = new UserCreationWizard(
 220                                                 session, userAdminService, jcrSecurityModel);
 221                                 WizardDialog dialog = new WizardDialog(addBtn.getShell(),
 222                                                 newUserWizard);
 223                                 if (dialog.open() == Dialog.OK)
 224                                         userTableCmp.refresh();
 225                         }
 226                 });
 227
 228                 // Configure
 229                 // userTableCmp.getTableViewer().addDoubleClickListener(
 230                 // new ViewDoubleClickListener());
 231                 // getViewSite().setSelectionProvider(userTableCmp.getTableViewer());
 232
 233                 // Add listener to refresh the list when something changes
 234                 // userStructureListener = new JcrUserListener(getSite().getShell()
 235                 // .getDisplay());
 236                 // JcrUtils.addListener(session, userStructureListener, Event.NODE_ADDED
 237                 // | Event.NODE_REMOVED, ArgeoJcrConstants.PEOPLE_BASE_PATH, null);
 238                 // userPropertiesListener = new JcrUserListener(getSite().getShell()
 239                 // .getDisplay());
 240                 // JcrUtils.addListener(session, userStructureListener,
 241                 // Event.PROPERTY_CHANGED | Event.PROPERTY_ADDED
 242                 // | Event.PROPERTY_REMOVED,
 243                 // ArgeoJcrConstants.PEOPLE_BASE_PATH,
 244                 // ArgeoTypes.ARGEO_USER_PROFILE);
 245
 246                 return userTableCmp;
 247         }
 248
 249         // protected Composite createUserPage(Composite parent) {
 250         // parent.setLayout(CmsUtils.noSpaceGridLayout());
 251         // ScrolledPage scrolled = new ScrolledPage(parent, SWT.NONE);
 252         // scrolled.setLayoutData(CmsUtils.fillAll());
 253         // scrolled.setLayout(CmsUtils.noSpaceGridLayout());
 254         // // TODO manage style
 255         // // CmsUtils.style(scrolled, "maintenance_user_form");
 256         //
 257         // Composite page = new Composite(scrolled, SWT.NONE);
 258         // page.setLayout(CmsUtils.noSpaceGridLayout());
 259         // page.setBackgroundMode(SWT.INHERIT_NONE);
 260         //
 261         // return page;
 262         // }
 263
 264         private boolean isAdmin(Node node) throws RepositoryException {
 265                 // FIXME clean this once new user management policy has been
 266                 // implemented.
 267                 AccessControlManager acm = node.getSession().getAccessControlManager();
 268                 Privilege[] privs = new Privilege[1];
 269                 privs[0] = acm.privilegeFromName(Privilege.JCR_ALL);
 270                 return acm.hasPrivileges("/", privs);
 271         }
 272
 273         // @Override
 274         // public void dispose() {
 275         // JcrUtils.removeListenerQuietly(session, userStructureListener);
 276         // JcrUtils.removeListenerQuietly(session, userPropertiesListener);
 277         // JcrUtils.logoutQuietly(session);
 278         // super.dispose();
 279         // }
 280         //
 281         // // public void setSession(Session session) {
 282         // // this.session = session;
 283         // // }
 284         //
 285         // public void refresh() {
 286         // this.getSite().getShell().getDisplay().asyncExec(new Runnable() {
 287         // @Override
 288         // public void run() {
 289         // userTableCmp.refresh();
 290         // }
 291         // });
 292         // }
 293         //
 294         // private class JcrUserListener implements EventListener {
 295         // private final Display display;
 296         //
 297         // public JcrUserListener(Display display) {
 298         // super();
 299         // this.display = display;
 300         // }
 301         //
 302         // @Override
 303         // public void onEvent(EventIterator events) {
 304         // display.asyncExec(new Runnable() {
 305         // @Override
 306         // public void run() {
 307         // userTableCmp.refresh();
 308         // }
 309         // });
 310         // }
 311         // }
 312         //
 313         // class ViewDoubleClickListener implements IDoubleClickListener {
 314         // public void doubleClick(DoubleClickEvent evt) {
 315         // if (evt.getSelection().isEmpty())
 316         // return;
 317         //
 318         // Object obj = ((IStructuredSelection) evt.getSelection())
 319         // .getFirstElement();
 320         // if (obj instanceof Node) {
 321         // try {
 322         // String username = ((Node) obj).getProperty(ARGEO_USER_ID)
 323         // .getString();
 324         // String commandId = OpenArgeoUserEditor.COMMAND_ID;
 325         // String paramName = OpenArgeoUserEditor.PARAM_USERNAME;
 326         // CommandUtils.callCommand(commandId, paramName, username);
 327         // } catch (RepositoryException e) {
 328         // throw new ArgeoException("Cannot open user editor", e);
 329         // }
 330         // }
 331         // }
 332
 333         /* DEPENDENCY INJECTION */
 334         public void setWorkspaceName(String workspaceName) {
 335                 this.userWkspName = workspaceName;
 336         }
 337
 338         public void setUserAdminService(UserAdminService userAdminService) {
 339                 this.userAdminService = userAdminService;
 340                 userPage.setUserAdminService(userAdminService);
 341         }
 342
 343         public void setJcrSecurityModel(JcrSecurityModel jcrSecurityModel) {
 344                 this.jcrSecurityModel = jcrSecurityModel;
 345                 // userPage.setJcrSecurityModel(jcrSecurityModel);
 346         }
 347
 348         public void setUserDetailsManager(UserDetailsManager userDetailsManager) {
 349                 // this.userDetailsManager = userDetailsManager;
 350                 // userPage.setUserDetailsManager(userDetailsManager);
 351         }
 352 }