eclipse/plugins/org.argeo.slc.client.ui/src/org/argeo/slc/client/ui/views/ProcessBuilderView.java

   1 package org.argeo.slc.client.ui.views;
   2
   3 import java.io.ByteArrayInputStream;
   4 import java.io.IOException;
   5 import java.util.ArrayList;
   6 import java.util.List;
   7 import java.util.Properties;
   8 import java.util.UUID;
   9
  10 import org.apache.commons.io.IOUtils;
  11 import org.argeo.slc.SlcException;
  12 import org.argeo.slc.client.ui.controllers.ProcessController;
  13 import org.argeo.slc.execution.ExecutionFlowDescriptor;
  14 import org.argeo.slc.process.RealizedFlow;
  15 import org.argeo.slc.process.SlcExecution;
  16 import org.argeo.slc.runtime.SlcAgent;
  17 import org.eclipse.jface.viewers.IStructuredContentProvider;
  18 import org.eclipse.jface.viewers.ITableLabelProvider;
  19 import org.eclipse.jface.viewers.LabelProvider;
  20 import org.eclipse.jface.viewers.TableViewer;
  21 import org.eclipse.jface.viewers.Viewer;
  22 import org.eclipse.jface.viewers.ViewerDropAdapter;
  23 import org.eclipse.swt.SWT;
  24 import org.eclipse.swt.dnd.DND;
  25 import org.eclipse.swt.dnd.TextTransfer;
  26 import org.eclipse.swt.dnd.Transfer;
  27 import org.eclipse.swt.dnd.TransferData;
  28 import org.eclipse.swt.graphics.Image;
  29 import org.eclipse.swt.layout.GridData;
  30 import org.eclipse.swt.widgets.Composite;
  31 import org.eclipse.swt.widgets.Table;
  32 import org.eclipse.swt.widgets.TableColumn;
  33 import org.eclipse.ui.part.ViewPart;
  34
  35 public class ProcessBuilderView extends ViewPart {
  36         public static final String ID = "org.argeo.slc.client.ui.processBuilderView";
  37
  38         // private final static Log log =
  39         // LogFactory.getLog(ProcessBuilderView.class);
  40
  41         private TableViewer viewer;
  42
  43         private List<RealizedFlow> realizedFlows = new ArrayList<RealizedFlow>();
  44
  45         private String currentAgentUuid = null;
  46         private ProcessController processController;
  47
  48         public void createPartControl(Composite parent) {
  49                 Table table = createTable(parent);
  50                 viewer = new TableViewer(table);
  51                 viewer.setLabelProvider(new ViewLabelProvider());
  52                 viewer.setContentProvider(new ViewContentProvider());
  53                 int operations = DND.DROP_COPY | DND.DROP_MOVE;
  54                 Transfer[] tt = new Transfer[] { TextTransfer.getInstance() };
  55                 viewer.addDropSupport(operations, tt, new ViewDropListener(viewer));
  56                 viewer.setInput(getViewSite());
  57         }
  58
  59         protected Table createTable(Composite parent) {
  60                 int style = SWT.SINGLE | SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL
  61                                 | SWT.FULL_SELECTION | SWT.HIDE_SELECTION;
  62
  63                 Table table = new Table(parent, style);
  64
  65                 GridData gridData = new GridData(GridData.FILL_BOTH);
  66                 gridData.grabExcessVerticalSpace = true;
  67                 gridData.grabExcessHorizontalSpace = true;
  68                 gridData.horizontalSpan = 3;
  69                 table.setLayoutData(gridData);
  70
  71                 table.setLinesVisible(true);
  72                 table.setHeaderVisible(true);
  73
  74                 TableColumn column = new TableColumn(table, SWT.LEFT, 0);
  75                 column.setText("Module");
  76                 column.setWidth(200);
  77
  78                 column = new TableColumn(table, SWT.LEFT, 1);
  79                 column.setText("Flow");
  80                 column.setWidth(200);
  81
  82                 return table;
  83         }
  84
  85         protected void execute() {
  86                 // TODO: use agent proxy to retrieve it
  87                 SlcAgent agent = null;
  88                 SlcExecution slcExecution = new SlcExecution();
  89                 slcExecution.setUuid(UUID.randomUUID().toString());
  90                 slcExecution.setRealizedFlows(realizedFlows);
  91
  92                 processController.execute(agent, slcExecution);
  93         }
  94
  95         public void setFocus() {
  96                 viewer.getControl().setFocus();
  97         }
  98
  99         public void setProcessController(ProcessController processController) {
 100                 this.processController = processController;
 101         }
 102
 103         protected class ViewContentProvider implements IStructuredContentProvider {
 104                 public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
 105                 }
 106
 107                 public void dispose() {
 108                 }
 109
 110                 public Object[] getElements(Object obj) {
 111                         return realizedFlows.toArray();
 112                 }
 113         }
 114
 115         protected class ViewLabelProvider extends LabelProvider implements
 116                         ITableLabelProvider {
 117                 public String getColumnText(Object obj, int index) {
 118                         RealizedFlow rf = (RealizedFlow) obj;
 119                         switch (index) {
 120                         case 0:
 121                                 return rf.getModuleName();
 122                         case 1:
 123                                 return rf.getFlowDescriptor().getName();
 124                         }
 125                         return getText(obj);
 126                 }
 127
 128                 public Image getColumnImage(Object obj, int index) {
 129                         return null;
 130                 }
 131
 132         }
 133
 134         protected class ViewDropListener extends ViewerDropAdapter {
 135
 136                 public ViewDropListener(Viewer viewer) {
 137                         super(viewer);
 138                 }
 139
 140                 @Override
 141                 public boolean performDrop(Object data) {
 142                         System.out.println(data);
 143                         Properties props = new Properties();
 144                         ByteArrayInputStream in = new ByteArrayInputStream(data.toString()
 145                                         .getBytes());
 146                         try {
 147                                 props.load(in);
 148                         } catch (IOException e) {
 149                                 throw new SlcException("Cannot create read realized flow", e);
 150                         } finally {
 151                                 IOUtils.closeQuietly(in);
 152                         }
 153
 154                         String agentId = props.getProperty("agentId");
 155                         if (currentAgentUuid == null)
 156                                 currentAgentUuid = agentId;
 157                         else if (currentAgentUuid.equals(agentId))
 158                                 return false;
 159
 160                         RealizedFlow rf = realizedFlowFromProperties(props);
 161                         realizedFlows.add(rf);
 162                         getViewer().refresh();
 163                         return true;
 164                 }
 165
 166                 private RealizedFlow realizedFlowFromProperties(Properties props) {
 167                         RealizedFlow rf = new RealizedFlow();
 168                         rf.setModuleName(props.getProperty("moduleName"));
 169                         rf.setModuleVersion(props.getProperty("moduleVersion"));
 170                         ExecutionFlowDescriptor efd = new ExecutionFlowDescriptor();
 171                         efd.setName(props.getProperty("flowName"));
 172                         rf.setFlowDescriptor(efd);
 173                         return rf;
 174                 }
 175
 176                 @Override
 177                 public boolean validateDrop(Object target, int operation,
 178                                 TransferData transferType) {
 179                         return true;
 180
 181                 }
 182
 183         }
 184
 185 }