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.argeo.security.ArgeoSecurityService;
   4 import org.argeo.security.ArgeoUser;
   5 import org.argeo.security.nature.SimpleUserNature;
   6 import org.argeo.security.ui.SecurityUiPlugin;
   7 import org.eclipse.jface.viewers.CellEditor;
   8 import org.eclipse.jface.viewers.CheckboxCellEditor;
   9 import org.eclipse.jface.viewers.ColumnLabelProvider;
  10 import org.eclipse.jface.viewers.EditingSupport;
  11 import org.eclipse.jface.viewers.IStructuredContentProvider;
  12 import org.eclipse.jface.viewers.ITableLabelProvider;
  13 import org.eclipse.jface.viewers.LabelProvider;
  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.IManagedForm;
  28 import org.eclipse.ui.forms.editor.FormEditor;
  29 import org.eclipse.ui.forms.editor.FormPage;
  30 import org.eclipse.ui.forms.widgets.ColumnLayout;
  31 import org.eclipse.ui.forms.widgets.FormToolkit;
  32 import org.eclipse.ui.forms.widgets.ScrolledForm;
  33
  34 public class DefaultUserMainPage extends FormPage {
  35         // We use icons
  36         private static final Image CHECKED = SecurityUiPlugin.getImageDescriptor(
  37                         "icons/security.gif").createImage();
  38
  39         private ArgeoUser user;
  40         private SimpleUserNature simpleNature;
  41
  42         private String simpleNatureType;
  43
  44         private Text firstName;
  45         private Text lastName;
  46         private Text email;
  47         private Text description;
  48         private TableViewer rolesViewer;
  49
  50         private ArgeoSecurityService securityService;
  51
  52         public DefaultUserMainPage(FormEditor editor,
  53                         ArgeoSecurityService securityService, ArgeoUser user) {
  54                 super(editor, "argeoUserEditor.mainPage", "Main");
  55                 this.securityService = securityService;
  56                 this.user = user;
  57                 this.simpleNature = SecurityUiPlugin.findSimpleUserNature(user,
  58                                 simpleNatureType);
  59         }
  60
  61         protected void createFormContent(final IManagedForm mf) {
  62                 ScrolledForm form = mf.getForm();
  63
  64                 // Set the title of the current form
  65                 form.setText(simpleNature.getFirstName() + " "
  66                                 + simpleNature.getLastName());
  67
  68                 ColumnLayout mainLayout = new ColumnLayout();
  69                 mainLayout.minNumColumns = 1;
  70                 mainLayout.maxNumColumns = 4;
  71
  72                 mainLayout.topMargin = 0;
  73                 mainLayout.bottomMargin = 5;
  74                 mainLayout.leftMargin = mainLayout.rightMargin = mainLayout.horizontalSpacing = mainLayout.verticalSpacing = 10;
  75                 form.getBody().setLayout(mainLayout);
  76
  77                 FormToolkit tk = mf.getToolkit();
  78
  79                 Composite body = tk.createComposite(form.getBody());
  80                 GridLayout layout = new GridLayout();
  81                 layout.marginWidth = layout.marginHeight = 0;
  82                 layout.numColumns = 2;
  83                 body.setLayout(layout);
  84
  85                 // Comments
  86                 tk.createLabel(body, "Username");
  87                 tk.createLabel(body, user.getUsername());
  88
  89                 firstName = createLT(mf, body, "First name",
  90                                 simpleNature.getFirstName());
  91                 lastName = createLT(mf, body, "Last name", simpleNature.getLastName());
  92                 email = createLT(mf, body, "Email", simpleNature.getEmail());
  93                 description = createLT(mf, body, "Description",
  94                                 simpleNature.getDescription());
  95
  96                 // Roles table
  97                 tk.createLabel(body, "Roles");
  98                 Table table = new Table(body, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  99                 GridData gridData = new GridData(SWT.FILL, SWT.FILL, true, true);
 100                 gridData.verticalSpan = 20;
 101                 table.setLayoutData(gridData);
 102                 table.setLinesVisible(true);
 103                 table.setHeaderVisible(false);
 104                 rolesViewer = new TableViewer(table);
 105
 106                 // check column
 107                 TableViewerColumn column = createTableViewerColumn("checked", 20);
 108                 column.setLabelProvider(new ColumnLabelProvider() {
 109                         public String getText(Object element) {
 110                                 return null;
 111                         }
 112
 113                         public Image getImage(Object element) {
 114                                 String role = element.toString();
 115                                 if (user.getRoles().contains(role)) {
 116                                         return CHECKED;
 117                                 } else {
 118                                         return null;
 119                                 }
 120                         }
 121                 });
 122                 column.setEditingSupport(new RoleEditingSupport(rolesViewer));
 123
 124                 // role column
 125                 column = createTableViewerColumn("Role", 200);
 126                 column.setLabelProvider(new ColumnLabelProvider() {
 127                         public String getText(Object element) {
 128                                 return element.toString();
 129                         }
 130
 131                         public Image getImage(Object element) {
 132                                 return null;
 133                         }
 134                 });
 135                 rolesViewer.setContentProvider(new RolesContentProvider());
 136                 rolesViewer.setInput(getEditorSite());
 137
 138         }
 139
 140         protected TableViewerColumn createTableViewerColumn(String title, int bound) {
 141                 final TableViewerColumn viewerColumn = new TableViewerColumn(
 142                                 rolesViewer, SWT.NONE);
 143                 final TableColumn column = viewerColumn.getColumn();
 144                 column.setText(title);
 145                 column.setWidth(bound);
 146                 column.setResizable(true);
 147                 column.setMoveable(true);
 148                 return viewerColumn;
 149
 150         }
 151
 152         /** Creates label and text. */
 153         protected Text createLT(final IManagedForm managedForm, Composite body,
 154                         String label, String value) {
 155                 FormToolkit toolkit = managedForm.getToolkit();
 156                 toolkit.createLabel(body, label);
 157                 Text text = toolkit.createText(body, value, SWT.BORDER);
 158                 text.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 159                 text.addModifyListener(new ModifyListener() {
 160                         public void modifyText(ModifyEvent e) {
 161                                 managedForm.dirtyStateChanged();
 162                         }
 163                 });
 164                 return text;
 165         }
 166
 167         public void setSimpleNatureType(String simpleNatureType) {
 168                 this.simpleNatureType = simpleNatureType;
 169         }
 170
 171         private class RolesContentProvider implements IStructuredContentProvider {
 172                 public Object[] getElements(Object inputElement) {
 173                         return securityService.getSecurityDao().listEditableRoles()
 174                                         .toArray();
 175                 }
 176
 177                 public void dispose() {
 178                 }
 179
 180                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 181                 }
 182         }
 183
 184         private class RolesLabelProvider extends LabelProvider implements
 185                         ITableLabelProvider {
 186                 public String getColumnText(Object element, int columnIndex) {
 187                         // Principal argeoUser = (Principal) element;
 188                         // switch (columnIndex) {
 189                         // case 0:
 190                         // return argeoUser.getName();
 191                         // case 1:
 192                         // return argeoUser.toString();
 193                         // default:
 194                         // throw new ArgeoException("Unmanaged column " + columnIndex);
 195                         // }
 196                         return element.toString();
 197                 }
 198
 199                 public Image getColumnImage(Object element, int columnIndex) {
 200                         // TODO Auto-generated method stub
 201                         return null;
 202                 }
 203
 204         }
 205
 206         class RoleEditingSupport extends EditingSupport {
 207
 208                 private final TableViewer viewer;
 209
 210                 public RoleEditingSupport(TableViewer viewer) {
 211                         super(viewer);
 212                         this.viewer = viewer;
 213                 }
 214
 215                 @Override
 216                 protected CellEditor getCellEditor(Object element) {
 217                         return new CheckboxCellEditor(null, SWT.CHECK | SWT.READ_ONLY);
 218
 219                 }
 220
 221                 @Override
 222                 protected boolean canEdit(Object element) {
 223                         return true;
 224                 }
 225
 226                 @Override
 227                 protected Object getValue(Object element) {
 228                         String role = element.toString();
 229                         return user.getRoles().contains(role);
 230
 231                 }
 232
 233                 @Override
 234                 protected void setValue(Object element, Object value) {
 235                         Boolean inRole = (Boolean) value;
 236                         String role = element.toString();
 237                         if (inRole && !user.getRoles().contains(role))
 238                                 user.getRoles().add(role);
 239                         else if (!inRole && user.getRoles().contains(role))
 240                                 user.getRoles().remove(role);
 241                         viewer.refresh();
 242                 }
 243         }
 244
 245 }