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