plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/views/AbstractQueryArtifactsView.java

   1 /*
   2  * Copyright (C) 2007-2012 Mathieu Baudier
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.client.ui.dist.views;
  17
  18 import java.util.ArrayList;
  19 import java.util.Calendar;
  20 import java.util.GregorianCalendar;
  21 import java.util.Iterator;
  22 import java.util.List;
  23
  24 import javax.jcr.RepositoryException;
  25 import javax.jcr.Session;
  26 import javax.jcr.query.Query;
  27 import javax.jcr.query.QueryResult;
  28 import javax.jcr.query.Row;
  29 import javax.jcr.query.RowIterator;
  30
  31 import org.apache.commons.logging.Log;
  32 import org.apache.commons.logging.LogFactory;
  33 import org.argeo.ArgeoException;
  34 import org.argeo.eclipse.ui.GenericTableComparator;
  35 import org.argeo.slc.client.ui.dist.utils.ArtifactsTableConfigurer;
  36 import org.argeo.slc.client.ui.dist.utils.GenericDoubleClickListener;
  37 import org.argeo.slc.jcr.SlcTypes;
  38 import org.eclipse.core.runtime.IStatus;
  39 import org.eclipse.core.runtime.Status;
  40 import org.eclipse.jface.dialogs.ErrorDialog;
  41 import org.eclipse.jface.viewers.IStructuredContentProvider;
  42 import org.eclipse.jface.viewers.ITableLabelProvider;
  43 import org.eclipse.jface.viewers.LabelProvider;
  44 import org.eclipse.jface.viewers.TableViewer;
  45 import org.eclipse.jface.viewers.TableViewerColumn;
  46 import org.eclipse.jface.viewers.Viewer;
  47 import org.eclipse.swt.SWT;
  48 import org.eclipse.swt.graphics.Image;
  49 import org.eclipse.swt.layout.GridData;
  50 import org.eclipse.swt.layout.GridLayout;
  51 import org.eclipse.swt.widgets.Composite;
  52 import org.eclipse.swt.widgets.Table;
  53 import org.eclipse.ui.part.ViewPart;
  54
  55 /** Factorizes useful methods to build a query view in a sashForm */
  56 public abstract class AbstractQueryArtifactsView extends ViewPart implements
  57                 SlcTypes {
  58         private static final Log log = LogFactory
  59                         .getLog(AbstractQueryArtifactsView.class);
  60
  61         // shortcuts
  62         final protected static String SAVB = "[" + SLC_ARTIFACT_VERSION_BASE + "]";
  63         final protected static String SBA = "[" + SLC_BUNDLE_ARTIFACT + "]";
  64         final protected static String SIP = "[" + SLC_IMPORTED_PACKAGE + "]";
  65         final protected static String SEP = "[" + SLC_EXPORTED_PACKAGE + "]";
  66
  67         /* DEPENDENCY INJECTION */
  68         private Session session;
  69         private List<String> columnProperties;
  70
  71         // This page widgets
  72         private TableViewer viewer;
  73         private List<TableViewerColumn> tableViewerColumns = new ArrayList<TableViewerColumn>();
  74         private ArtifactsTableConfigurer tableConfigurer;
  75         private GenericTableComparator comparator;
  76
  77         // to be set by client to display all columns
  78         private boolean displayAllColumns = false;
  79
  80         protected void createResultPart(Composite parent) {
  81                 viewer = new TableViewer(parent);
  82                 Table table = viewer.getTable();
  83                 table.getParent().setLayout(new GridLayout(1, false));
  84                 table.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
  85                 viewer.getTable().setHeaderVisible(true);
  86                 viewer.getTable().setLinesVisible(true);
  87
  88                 viewer.setLabelProvider(new ViewLabelProvider());
  89                 viewer.setContentProvider(new ViewContentProvider());
  90                 viewer.addDoubleClickListener(new GenericDoubleClickListener(null));
  91
  92                 tableConfigurer = new ArtifactsTableConfigurer(viewer, 1,
  93                                 GenericTableComparator.DESCENDING);
  94
  95                 comparator = tableConfigurer.getComparator();
  96                 viewer.setComparator(comparator);
  97         }
  98
  99         protected void executeQuery(String statement) {
 100                 try {
 101                         Calendar stStamp = new GregorianCalendar();
 102                         if (log.isDebugEnabled()) {
 103                                 log.debug("Executed query: " + statement);
 104                         }
 105                         QueryResult qr = session.getWorkspace().getQueryManager()
 106                                         .createQuery(statement, Query.JCR_SQL2).execute();
 107
 108                         if (log.isDebugEnabled()) {
 109                                 Calendar enStamp = new GregorianCalendar();
 110                                 long duration = enStamp.getTimeInMillis()
 111                                                 - stStamp.getTimeInMillis();
 112                                 log.debug("Query executed in : " + duration / 1000 + "s.");
 113                         }
 114
 115                         // remove previous columns
 116                         for (TableViewerColumn tvc : tableViewerColumns)
 117                                 tvc.getColumn().dispose();
 118
 119                         // If a pre(-defined list of columns has been injected, we use it,
 120                         // otherwise we display all results of the resultSet
 121                         if (!displayAllColumns && columnProperties != null) {
 122                                 int i = 0;
 123
 124                                 Iterator<String> it = columnProperties.iterator();
 125                                 while (it.hasNext()) {
 126                                         String columnName = it.next();
 127
 128                                         TableViewerColumn tvc = new TableViewerColumn(viewer,
 129                                                         SWT.NONE);
 130                                         tableConfigurer.configureColumn(columnName, tvc, i);
 131                                         tvc.setLabelProvider(tableConfigurer
 132                                                         .getLabelProvider(columnName));
 133                                         tableViewerColumns.add(tvc);
 134                                         i++;
 135                                 }
 136                         } else {
 137                                 int i = 0;
 138                                 for (final String columnName : qr.getColumnNames()) {
 139                                         TableViewerColumn tvc = new TableViewerColumn(viewer,
 140                                                         SWT.NONE);
 141                                         // Small hack to remove prefix from the column name
 142                                         // String tmpStr = columnName.substring(columnName
 143                                         // .lastIndexOf(".") + 1);
 144                                         tableConfigurer.configureColumn(columnName, tvc, i);
 145                                         tvc.setLabelProvider(tableConfigurer
 146                                                         .getLabelProvider(columnName));
 147                                         tableViewerColumns.add(tvc);
 148                                         i++;
 149                                 }
 150                         }
 151                         // We must create a local list because query result can be read only
 152                         // once.
 153                         try {
 154                                 List<Row> rows = new ArrayList<Row>();
 155                                 RowIterator rit = qr.getRows();
 156                                 while (rit.hasNext()) {
 157                                         rows.add(rit.nextRow());
 158                                 }
 159                                 viewer.setInput(rows);
 160                         } catch (RepositoryException e) {
 161                                 throw new ArgeoException("Cannot read query result", e);
 162                         }
 163
 164                 } catch (RepositoryException e) {
 165                         ErrorDialog.openError(null, "Error", "Cannot execute JCR query: "
 166                                         + statement, new Status(IStatus.ERROR,
 167                                         "org.argeo.eclipse.ui.jcr", e.getMessage()));
 168                 }
 169         }
 170
 171         /**
 172          * Client must use this method to display all columns of the result set
 173          * instead of a limited predifined and injected set
 174          **/
 175         public void displayAllColumns(boolean flag) {
 176                 displayAllColumns = flag;
 177         }
 178
 179         // Can be overridden by subclasses.
 180         protected String generateSelectStatement() {
 181                 StringBuffer sb = new StringBuffer("select " + SAVB + ".* ");
 182                 return sb.toString();
 183         }
 184
 185         protected String generateFromStatement() {
 186                 StringBuffer sb = new StringBuffer(" from ");
 187                 sb.append(SAVB);
 188                 sb.append(" ");
 189                 return sb.toString();
 190         }
 191
 192         // Providers
 193         protected class ViewContentProvider implements IStructuredContentProvider {
 194
 195                 public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
 196                 }
 197
 198                 public void dispose() {
 199                 }
 200
 201                 @SuppressWarnings("unchecked")
 202                 public Object[] getElements(Object obj) {
 203                         return ((List<String[]>) obj).toArray();
 204                 }
 205         }
 206
 207         protected class ViewLabelProvider extends LabelProvider implements
 208                         ITableLabelProvider {
 209                 public String getColumnText(Object obj, int index) {
 210                         if (!(obj instanceof String[]))
 211                                 return "Object is not properly formatted ";
 212
 213                         String[] value = (String[]) obj;
 214
 215                         return value[index];
 216                 }
 217
 218                 public Image getColumnImage(Object obj, int index) {
 219                         return null;
 220                 }
 221         }
 222
 223         /* DEPENDENCY INJECTION */
 224         public void setSession(Session session) {
 225                 this.session = session;
 226         }
 227
 228         public void setColumnProperties(List<String> columnProperties) {
 229                 this.columnProperties = columnProperties;
 230         }
 231 }