security/plugins/org.argeo.security.ui/src/main/java/org/argeo/security/ui/editors/DefaultUserMainPage.java

   1 package org.argeo.security.ui.editors;
   2
   3 import org.apache.commons.logging.Log;
   4 import org.apache.commons.logging.LogFactory;
   5 import org.argeo.security.ArgeoSecurityService;
   6 import org.argeo.security.ArgeoUser;
   7 import org.argeo.security.SimpleArgeoUser;
   8 import org.argeo.security.nature.SimpleUserNature;
   9 import org.argeo.security.ui.SecurityUiPlugin;
  10 import org.eclipse.jface.viewers.CellEditor;
  11 import org.eclipse.jface.viewers.CheckboxCellEditor;
  12 import org.eclipse.jface.viewers.ColumnLabelProvider;
  13 import org.eclipse.jface.viewers.EditingSupport;
  14 import org.eclipse.jface.viewers.IStructuredContentProvider;
  15 import org.eclipse.jface.viewers.TableViewer;
  16 import org.eclipse.jface.viewers.TableViewerColumn;
  17 import org.eclipse.jface.viewers.Viewer;
  18 import org.eclipse.swt.SWT;
  19 import org.eclipse.swt.events.ModifyEvent;
  20 import org.eclipse.swt.events.ModifyListener;
  21 import org.eclipse.swt.graphics.Image;
  22 import org.eclipse.swt.layout.GridData;
  23 import org.eclipse.swt.layout.GridLayout;
  24 import org.eclipse.swt.widgets.Composite;
  25 import org.eclipse.swt.widgets.Table;
  26 import org.eclipse.swt.widgets.TableColumn;
  27 import org.eclipse.swt.widgets.Text;
  28 import org.eclipse.ui.forms.AbstractFormPart;
  29 import org.eclipse.ui.forms.IManagedForm;
  30 import org.eclipse.ui.forms.SectionPart;
  31 import org.eclipse.ui.forms.editor.FormEditor;
  32 import org.eclipse.ui.forms.editor.FormPage;
  33 import org.eclipse.ui.forms.widgets.ColumnLayout;
  34 import org.eclipse.ui.forms.widgets.FormToolkit;
  35 import org.eclipse.ui.forms.widgets.ScrolledForm;
  36 import org.eclipse.ui.forms.widgets.Section;
  37
  38 /**
  39  * Display/edit the properties common to all {@link ArgeoUser} (username and
  40  * roles) as well as the properties of the {@link SimpleUserNature}.
  41  */
  42 public class DefaultUserMainPage extends FormPage {
  43         final static String ID = "argeoUserEditor.mainPage";
  44
  45         private final static Log log = LogFactory.getLog(DefaultUserMainPage.class);
  46         private final static Image ROLE_CHECKED = SecurityUiPlugin
  47                         .getImageDescriptor("icons/security.gif").createImage();
  48
  49         private ArgeoUser user;
  50         private SimpleUserNature simpleNature;
  51         private String simpleNatureType;
  52         private ArgeoSecurityService securityService;
  53
  54         public DefaultUserMainPage(FormEditor editor,
  55                         ArgeoSecurityService securityService, ArgeoUser user) {
  56                 super(editor, ID, "Main");
  57                 this.securityService = securityService;
  58                 this.user = user;
  59                 this.simpleNature = SimpleUserNature.findSimpleUserNature(user,
  60                                 simpleNatureType);
  61         }
  62
  63         protected void createFormContent(final IManagedForm mf) {
  64                 ScrolledForm form = mf.getForm();
  65                 form.setText(simpleNature.getFirstName() + " "
  66                                 + simpleNature.getLastName());
  67                 ColumnLayout mainLayout = new ColumnLayout();
  68                 mainLayout.minNumColumns = 1;
  69                 mainLayout.maxNumColumns = 4;
  70                 mainLayout.topMargin = 0;
  71                 mainLayout.bottomMargin = 5;
  72                 mainLayout.leftMargin = mainLayout.rightMargin = mainLayout.horizontalSpacing = mainLayout.verticalSpacing = 10;
  73                 form.getBody().setLayout(mainLayout);
  74
  75                 createGeneralPart(form.getBody());
  76                 createRolesPart(form.getBody());
  77                 createPassworPart(form.getBody());
  78         }
  79
  80         /** Creates the general section */
  81         protected void createGeneralPart(Composite parent) {
  82                 FormToolkit tk = getManagedForm().getToolkit();
  83                 Section section = tk.createSection(parent, Section.TITLE_BAR);
  84                 section.setText("General");
  85
  86                 Composite body = tk.createComposite(section, SWT.WRAP);
  87                 section.setClient(body);
  88                 GridLayout layout = new GridLayout();
  89                 layout.marginWidth = layout.marginHeight = 0;
  90                 layout.numColumns = 2;
  91                 body.setLayout(layout);
  92
  93                 // add widgets (view)
  94                 final Text username;
  95                 if (user.getUsername() != null) {
  96                         tk.createLabel(body, "Username");
  97                         tk.createLabel(body, user.getUsername());
  98                         username = null;
  99                 } else {
 100                         username = createLT(body, "Username", "");
 101                 }
 102                 final Text firstName = createLT(body, "First name",
 103                                 simpleNature.getFirstName());
 104                 final Text lastName = createLT(body, "Last name",
 105                                 simpleNature.getLastName());
 106                 final Text email = createLT(body, "Email", simpleNature.getEmail());
 107                 final Text description = createLT(body, "Description",
 108                                 simpleNature.getDescription());
 109
 110                 // create form part (controller)
 111                 AbstractFormPart part = new SectionPart(section) {
 112                         public void commit(boolean onSave) {
 113                                 if (username != null) {
 114                                         ((SimpleArgeoUser) user).setUsername(username.getText());
 115                                         username.setEditable(false);
 116                                         username.setEnabled(false);
 117                                 }
 118                                 simpleNature.setFirstName(firstName.getText());
 119                                 simpleNature.setLastName(lastName.getText());
 120                                 simpleNature.setEmail(email.getText());
 121                                 simpleNature.setDescription(description.getText());
 122                                 super.commit(onSave);
 123                                 if (log.isTraceEnabled())
 124                                         log.trace("General part committed");
 125                         }
 126                 };
 127                 if (username != null)
 128                         username.addModifyListener(new FormPartML(part));
 129                 firstName.addModifyListener(new FormPartML(part));
 130                 lastName.addModifyListener(new FormPartML(part));
 131                 email.addModifyListener(new FormPartML(part));
 132                 description.addModifyListener(new FormPartML(part));
 133                 getManagedForm().addPart(part);
 134         }
 135
 136         /** Creates the password section */
 137         protected void createPassworPart(Composite parent) {
 138                 FormToolkit tk = getManagedForm().getToolkit();
 139                 Section section = tk.createSection(parent, Section.TITLE_BAR);
 140                 section.setText("Password");
 141
 142                 Composite body = tk.createComposite(section, SWT.WRAP);
 143                 section.setClient(body);
 144                 GridLayout layout = new GridLayout();
 145                 layout.marginWidth = layout.marginHeight = 0;
 146                 layout.numColumns = 2;
 147                 body.setLayout(layout);
 148
 149                 // add widgets (view)
 150                 final Text password1 = createLP(body, "New password", "");
 151                 final Text password2 = createLP(body, "Repeat password", "");
 152                 // create form part (controller)
 153                 AbstractFormPart part = new SectionPart(section) {
 154                         public void commit(boolean onSave) {
 155                                 if (!password1.getText().equals("")
 156                                                 && password1.getText().equals(password2.getText())) {
 157                                         ((SimpleArgeoUser) user).setPassword(password1.getText());
 158                                 }
 159                                 super.commit(onSave);
 160                                 if (log.isTraceEnabled())
 161                                         log.trace("Password part committed");
 162                         }
 163                 };
 164                 password1.addModifyListener(new FormPartML(part));
 165                 password2.addModifyListener(new FormPartML(part));
 166                 getManagedForm().addPart(part);
 167         }
 168
 169         /** Creates the role section */
 170         protected void createRolesPart(Composite parent) {
 171                 FormToolkit tk = getManagedForm().getToolkit();
 172                 Section section = tk.createSection(parent, Section.DESCRIPTION
 173                                 | Section.TITLE_BAR);
 174                 section.setText("Roles");
 175                 section.setDescription("Roles define "
 176                                 + "the authorizations for this user.");
 177                 Table table = new Table(section, SWT.MULTI | SWT.H_SCROLL
 178                                 | SWT.V_SCROLL);
 179                 section.setClient(table);
 180
 181                 AbstractFormPart part = new SectionPart(section) {
 182                         public void commit(boolean onSave) {
 183                                 // roles have already been modified in editing
 184                                 super.commit(onSave);
 185                                 if (log.isTraceEnabled())
 186                                         log.trace("Role part committed");
 187                         }
 188                 };
 189                 getManagedForm().addPart(part);
 190
 191                 GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
 192                 gridData.verticalSpan = 20;
 193                 table.setLayoutData(gridData);
 194                 table.setLinesVisible(true);
 195                 table.setHeaderVisible(false);
 196                 TableViewer viewer = new TableViewer(table);
 197
 198                 // check column
 199                 TableViewerColumn column = createTableViewerColumn(viewer, "checked",
 200                                 20);
 201                 column.setLabelProvider(new ColumnLabelProvider() {
 202                         public String getText(Object element) {
 203                                 return null;
 204                         }
 205
 206                         public Image getImage(Object element) {
 207                                 String role = element.toString();
 208                                 if (user.getRoles().contains(role)) {
 209                                         return ROLE_CHECKED;
 210                                 } else {
 211                                         return null;
 212                                 }
 213                         }
 214                 });
 215                 column.setEditingSupport(new RoleEditingSupport(viewer, part));
 216
 217                 // role column
 218                 column = createTableViewerColumn(viewer, "Role", 200);
 219                 column.setLabelProvider(new ColumnLabelProvider() {
 220                         public String getText(Object element) {
 221                                 return element.toString();
 222                         }
 223
 224                         public Image getImage(Object element) {
 225                                 return null;
 226                         }
 227                 });
 228                 viewer.setContentProvider(new RolesContentProvider());
 229                 viewer.setInput(getEditorSite());
 230         }
 231
 232         protected TableViewerColumn createTableViewerColumn(TableViewer viewer,
 233                         String title, int bound) {
 234                 final TableViewerColumn viewerColumn = new TableViewerColumn(viewer,
 235                                 SWT.NONE);
 236                 final TableColumn column = viewerColumn.getColumn();
 237                 column.setText(title);
 238                 column.setWidth(bound);
 239                 column.setResizable(true);
 240                 column.setMoveable(true);
 241                 return viewerColumn;
 242
 243         }
 244
 245         /** Creates label and text. */
 246         protected Text createLT(Composite body, String label, String value) {
 247                 FormToolkit toolkit = getManagedForm().getToolkit();
 248                 toolkit.createLabel(body, label);
 249                 Text text = toolkit.createText(body, value, SWT.BORDER);
 250                 text.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 251                 return text;
 252         }
 253
 254         /** Creates label and password. */
 255         protected Text createLP(Composite body, String label, String value) {
 256                 FormToolkit toolkit = getManagedForm().getToolkit();
 257                 toolkit.createLabel(body, label);
 258                 Text text = toolkit.createText(body, value, SWT.BORDER | SWT.PASSWORD);
 259                 text.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 260                 return text;
 261         }
 262
 263         public void setSimpleNatureType(String simpleNatureType) {
 264                 this.simpleNatureType = simpleNatureType;
 265         }
 266
 267         private class FormPartML implements ModifyListener {
 268                 private AbstractFormPart formPart;
 269
 270                 public FormPartML(AbstractFormPart generalPart) {
 271                         this.formPart = generalPart;
 272                 }
 273
 274                 public void modifyText(ModifyEvent e) {
 275                         formPart.markDirty();
 276                 }
 277
 278         }
 279
 280         private class RolesContentProvider implements IStructuredContentProvider {
 281                 public Object[] getElements(Object inputElement) {
 282                         return securityService.listEditableRoles().toArray();
 283                 }
 284
 285                 public void dispose() {
 286                 }
 287
 288                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 289                 }
 290         }
 291
 292         /** Select the columns by editing the checkbox in the first column */
 293         class RoleEditingSupport extends EditingSupport {
 294
 295                 private final TableViewer viewer;
 296                 private final AbstractFormPart formPart;
 297
 298                 public RoleEditingSupport(TableViewer viewer, AbstractFormPart formPart) {
 299                         super(viewer);
 300                         this.viewer = viewer;
 301                         this.formPart = formPart;
 302                 }
 303
 304                 @Override
 305                 protected CellEditor getCellEditor(Object element) {
 306                         return new CheckboxCellEditor(null, SWT.CHECK | SWT.READ_ONLY);
 307
 308                 }
 309
 310                 @Override
 311                 protected boolean canEdit(Object element) {
 312                         return true;
 313                 }
 314
 315                 @Override
 316                 protected Object getValue(Object element) {
 317                         String role = element.toString();
 318                         return user.getRoles().contains(role);
 319
 320                 }
 321
 322                 @Override
 323                 protected void setValue(Object element, Object value) {
 324                         Boolean inRole = (Boolean) value;
 325                         String role = element.toString();
 326                         if (inRole && !user.getRoles().contains(role)) {
 327                                 user.getRoles().add(role);
 328                                 formPart.markDirty();
 329                         } else if (!inRole && user.getRoles().contains(role)) {
 330                                 user.getRoles().remove(role);
 331                                 formPart.markDirty();
 332                         }
 333                         viewer.refresh();
 334                 }
 335         }
 336
 337 }