org.argeo.eclipse.ui/src/org/argeo/eclipse/ui/parts/JcrUsersTable.java

   1 package org.argeo.eclipse.ui.parts;
   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.Property;
   9 import javax.jcr.PropertyType;
  10 import javax.jcr.RepositoryException;
  11 import javax.jcr.Session;
  12 import javax.jcr.query.QueryManager;
  13 import javax.jcr.query.QueryResult;
  14 import javax.jcr.query.qom.Constraint;
  15 import javax.jcr.query.qom.Ordering;
  16 import javax.jcr.query.qom.QueryObjectModel;
  17 import javax.jcr.query.qom.QueryObjectModelFactory;
  18 import javax.jcr.query.qom.Selector;
  19 import javax.jcr.query.qom.StaticOperand;
  20
  21 import org.argeo.ArgeoException;
  22 import org.argeo.eclipse.ui.EclipseUiUtils;
  23 import org.argeo.eclipse.ui.jcr.JcrUiUtils;
  24 import org.argeo.eclipse.ui.jcr.lists.JcrColumnDefinition;
  25 import org.argeo.eclipse.ui.jcr.lists.NodeViewerComparator;
  26 import org.argeo.eclipse.ui.jcr.lists.SimpleJcrNodeLabelProvider;
  27 import org.argeo.eclipse.ui.utils.ViewerUtils;
  28 import org.argeo.jcr.ArgeoNames;
  29 import org.argeo.jcr.ArgeoTypes;
  30 import org.argeo.jcr.JcrUtils;
  31 import org.eclipse.jface.viewers.CheckboxTableViewer;
  32 import org.eclipse.jface.viewers.ColumnLabelProvider;
  33 import org.eclipse.jface.viewers.IStructuredContentProvider;
  34 import org.eclipse.jface.viewers.TableViewer;
  35 import org.eclipse.jface.viewers.TableViewerColumn;
  36 import org.eclipse.jface.viewers.Viewer;
  37 import org.eclipse.swt.SWT;
  38 import org.eclipse.swt.events.ModifyEvent;
  39 import org.eclipse.swt.events.ModifyListener;
  40 import org.eclipse.swt.events.SelectionAdapter;
  41 import org.eclipse.swt.events.SelectionEvent;
  42 import org.eclipse.swt.graphics.Font;
  43 import org.eclipse.swt.layout.GridData;
  44 import org.eclipse.swt.layout.GridLayout;
  45 import org.eclipse.swt.widgets.Composite;
  46 import org.eclipse.swt.widgets.Table;
  47 import org.eclipse.swt.widgets.Text;
  48
  49 /**
  50  * Composite that contains a JFace table to display users that are stored in JCR
  51  * following the Argeo Conventions (See {@link ArgeoNames}
  52  */
  53 public class JcrUsersTable extends Composite implements ArgeoNames {
  54         // private final static Log log =
  55         // LogFactory.getLog(UserTableComposite.class);
  56
  57         private static final long serialVersionUID = -7385959046279360420L;
  58
  59         private Session session;
  60
  61         private boolean hasFilter;
  62         private boolean hasSelectionColumn;
  63         private int tableStyle;
  64
  65         private TableViewer usersViewer;
  66         private Text filterTxt;
  67         private String filterHelpMsg = "Type filter criterion "
  68                         + "separated by a space";
  69
  70         private Font italic;
  71         private Font bold;
  72
  73         /** Overwrite to display other columns */
  74         public List<JcrColumnDefinition> getColumnsDef() {
  75                 List<JcrColumnDefinition> columnDefs = new ArrayList<JcrColumnDefinition>();
  76
  77                 // User ID
  78                 columnDefs.add(new JcrColumnDefinition(ARGEO_USER_ID,
  79                                 PropertyType.STRING, "User ID", 100));
  80                 // Displayed name
  81                 columnDefs.add(new JcrColumnDefinition(Property.JCR_TITLE,
  82                                 PropertyType.STRING, "Name", 150));
  83
  84                 // E-mail
  85                 columnDefs.add(new JcrColumnDefinition(ARGEO_PRIMARY_EMAIL,
  86                                 PropertyType.STRING, "E-mail", 150));
  87
  88                 // Description
  89                 columnDefs.add(new JcrColumnDefinition(Property.JCR_DESCRIPTION,
  90                                 PropertyType.STRING, "Description", 200));
  91
  92                 return columnDefs;
  93         }
  94
  95         public JcrUsersTable(Composite parent, int style, Session session) {
  96                 super(parent, SWT.NO_FOCUS);
  97                 this.tableStyle = style;
  98                 this.session = session;
  99         }
 100
 101         /**
 102          *
 103          * @param addFilter
 104          *            choose to add a field to filter results or not
 105          * @param addSelection
 106          *            choose to add a column to select some of the displayed results
 107          *            or not
 108          */
 109         public void populate(boolean addFilter, boolean addSelection) {
 110                 // initialization
 111                 Composite parent = this;
 112                 italic = EclipseUiUtils.getItalicFont(parent);
 113                 bold = EclipseUiUtils.getBoldFont(parent);
 114                 hasFilter = addFilter;
 115                 hasSelectionColumn = addSelection;
 116
 117                 // Main Layout
 118                 GridLayout layout = EclipseUiUtils.noSpaceGridLayout();
 119                 layout.verticalSpacing = 5;
 120                 this.setLayout(layout);
 121                 if (hasFilter)
 122                         createFilterPart(parent);
 123                 usersViewer = createTableViewer(parent);
 124                 // EclipseUiSpecificUtils.enableToolTipSupport(usersViewer);
 125                 usersViewer.setContentProvider(new UsersContentProvider());
 126                 refreshFilteredList();
 127         }
 128
 129         public List<Node> getSelectedUsers() {
 130                 if (hasSelectionColumn) {
 131                         Object[] elements = ((CheckboxTableViewer) usersViewer)
 132                                         .getCheckedElements();
 133
 134                         List<Node> result = new ArrayList<Node>();
 135                         for (Object obj : elements) {
 136                                 result.add((Node) obj);
 137                         }
 138                         return result;
 139                 } else
 140                         throw new ArgeoException("Unvalid request: no selection column "
 141                                         + "has been created for the current table");
 142         }
 143
 144         /** Returns the User table viewer, typically to add doubleclick listener */
 145         public TableViewer getTableViewer() {
 146                 return usersViewer;
 147         }
 148
 149         /** Returns filter String or null */
 150         protected String getFilterString() {
 151                 return hasFilter ? filterTxt.getText() : null;
 152         }
 153
 154         private TableViewer createTableViewer(final Composite parent) {
 155                 int style = tableStyle | SWT.H_SCROLL | SWT.V_SCROLL;
 156                 if (hasSelectionColumn)
 157                         style = style | SWT.CHECK;
 158
 159                 Table table = new Table(parent, style);
 160                 table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
 161
 162                 TableViewer viewer;
 163                 if (hasSelectionColumn)
 164                         viewer = new CheckboxTableViewer(table);
 165                 else
 166                         viewer = new TableViewer(table);
 167                 table.setLinesVisible(true);
 168                 table.setHeaderVisible(true);
 169
 170                 TableViewerColumn column;
 171                 int offset = 0;
 172                 if (hasSelectionColumn) {
 173                         offset = 1;
 174                         column = ViewerUtils.createTableViewerColumn(viewer, "", SWT.NONE,
 175                                         25);
 176                         column.setLabelProvider(new ColumnLabelProvider() {
 177                                 private static final long serialVersionUID = 1L;
 178
 179                                 @Override
 180                                 public String getText(Object element) {
 181                                         return null;
 182                                 }
 183                         });
 184                         SelectionAdapter selectionAdapter = new SelectionAdapter() {
 185                                 private static final long serialVersionUID = 1L;
 186
 187                                 boolean allSelected = false;
 188
 189                                 @Override
 190                                 public void widgetSelected(SelectionEvent e) {
 191                                         allSelected = !allSelected;
 192                                         ((CheckboxTableViewer) usersViewer)
 193                                                         .setAllChecked(allSelected);
 194                                 }
 195                         };
 196                         column.getColumn().addSelectionListener(selectionAdapter);
 197                 }
 198
 199                 // Create other columns
 200                 List<JcrColumnDefinition> colDefs = getColumnsDef();
 201
 202                 NodeViewerComparator comparator = new NodeViewerComparator();
 203                 int i = offset;
 204                 for (JcrColumnDefinition colDef : colDefs) {
 205                         column = ViewerUtils.createTableViewerColumn(viewer,
 206                                         colDef.getHeaderLabel(), SWT.NONE, colDef.getColumnSize());
 207                         column.setLabelProvider(new CLProvider(colDef.getPropertyName()));
 208                         column.getColumn().addSelectionListener(
 209                                         JcrUiUtils.getNodeSelectionAdapter(i,
 210                                                         colDef.getPropertyType(), colDef.getPropertyName(),
 211                                                         comparator, viewer));
 212                         i++;
 213                 }
 214
 215                 // IMPORTANT: initialize comparator before setting it
 216                 JcrColumnDefinition firstCol = colDefs.get(0);
 217                 comparator.setColumn(firstCol.getPropertyType(),
 218                                 firstCol.getPropertyName());
 219                 viewer.setComparator(comparator);
 220
 221                 return viewer;
 222         }
 223
 224         private class CLProvider extends SimpleJcrNodeLabelProvider {
 225
 226                 private static final long serialVersionUID = 1L;
 227
 228                 public CLProvider(String propertyName) {
 229                         super(propertyName);
 230                 }
 231
 232                 public String getToolTipText(Object element) {
 233                         return getText(element);
 234                 }
 235
 236                 @Override
 237                 public Font getFont(Object elem) {
 238                         // self
 239                         String username = getProperty(elem, ARGEO_USER_ID);
 240                         if (username.equals(session.getUserID()))
 241                                 return bold;
 242                         // disabled
 243                         try {
 244                                 Node userProfile = (Node) elem;
 245                                 if (!userProfile.getProperty(ARGEO_ENABLED).getBoolean())
 246                                         return italic;
 247                                 else
 248                                         return null;
 249                         } catch (RepositoryException e) {
 250                                 throw new ArgeoException("Cannot get font for " + username, e);
 251                         }
 252                 }
 253         }
 254
 255         @Override
 256         public boolean setFocus() {
 257                 usersViewer.getTable().setFocus();
 258                 return true;
 259         }
 260
 261         @Override
 262         public void dispose() {
 263                 super.dispose();
 264         }
 265
 266         public void refresh() {
 267                 refreshFilteredList();
 268         }
 269
 270         private String getProperty(Object element, String name) {
 271                 try {
 272                         Node userProfile = (Node) element;
 273                         return userProfile.hasProperty(name) ? userProfile
 274                                         .getProperty(name).getString() : "";
 275                 } catch (RepositoryException e) {
 276                         throw new ArgeoException("Cannot get property " + name, e);
 277                 }
 278         }
 279
 280         private class UsersContentProvider implements IStructuredContentProvider {
 281                 private static final long serialVersionUID = 1L;
 282
 283                 public Object[] getElements(Object inputElement) {
 284                         return (Object[]) inputElement;
 285                 }
 286
 287                 public void dispose() {
 288                 }
 289
 290                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 291                 }
 292         }
 293
 294         /* MANAGE FILTER */
 295         private void createFilterPart(Composite parent) {
 296                 // Text Area for the filter
 297                 filterTxt = new Text(parent, SWT.BORDER | SWT.SEARCH | SWT.ICON_SEARCH
 298                                 | SWT.ICON_CANCEL);
 299                 filterTxt.setMessage(filterHelpMsg);
 300                 filterTxt.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL
 301                                 | GridData.HORIZONTAL_ALIGN_FILL));
 302                 filterTxt.addModifyListener(new ModifyListener() {
 303                         private static final long serialVersionUID = 1L;
 304
 305                         public void modifyText(ModifyEvent event) {
 306                                 refreshFilteredList();
 307                         }
 308                 });
 309         }
 310
 311         /**
 312          * Refresh the user list: caller might overwrite in order to display a
 313          * subset of all users, typically to remove current user from the list
 314          */
 315         protected void refreshFilteredList() {
 316                 List<Node> nodes;
 317                 try {
 318                         nodes = JcrUtils.nodeIteratorToList(listFilteredElements(session,
 319                                         hasFilter ? filterTxt.getText() : null));
 320                         usersViewer.setInput(nodes.toArray());
 321                 } catch (RepositoryException e) {
 322                         throw new ArgeoException("Unable to list users", e);
 323                 }
 324         }
 325
 326         /**
 327          * Build repository request : caller might overwrite in order to display a
 328          * subset of all users
 329          */
 330         protected NodeIterator listFilteredElements(Session session, String filter)
 331                         throws RepositoryException {
 332                 QueryManager queryManager = session.getWorkspace().getQueryManager();
 333                 QueryObjectModelFactory factory = queryManager.getQOMFactory();
 334
 335                 Selector source = factory.selector(ArgeoTypes.ARGEO_USER_PROFILE,
 336                                 ArgeoTypes.ARGEO_USER_PROFILE);
 337
 338                 // Dynamically build constraint depending on the filter String
 339                 Constraint defaultC = null;
 340                 if (filter != null && !"".equals(filter.trim())) {
 341                         String[] strs = filter.trim().split(" ");
 342                         for (String token : strs) {
 343                                 StaticOperand so = factory.literal(session.getValueFactory()
 344                                                 .createValue("*" + token + "*"));
 345                                 Constraint currC = factory.fullTextSearch(
 346                                                 source.getSelectorName(), null, so);
 347                                 if (defaultC == null)
 348                                         defaultC = currC;
 349                                 else
 350                                         defaultC = factory.and(defaultC, currC);
 351                         }
 352                 }
 353
 354                 Ordering order = factory.ascending(factory.propertyValue(
 355                                 source.getSelectorName(), ARGEO_USER_ID));
 356                 Ordering[] orderings = { order };
 357
 358                 QueryObjectModel query = factory.createQuery(source, defaultC,
 359                                 orderings, null);
 360
 361                 QueryResult result = query.execute();
 362                 return result.getNodes();
 363         }
 364 }