package org.simantics.district.imports.ui; import java.io.IOException; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.function.Consumer; import org.apache.commons.csv.CSVRecord; import org.eclipse.jface.dialogs.IPageChangeProvider; import org.eclipse.jface.dialogs.IPageChangedListener; import org.eclipse.jface.dialogs.PageChangedEvent; import org.eclipse.jface.layout.GridDataFactory; import org.eclipse.jface.layout.TableColumnLayout; import org.eclipse.jface.viewers.ColumnWeightData; import org.eclipse.jface.wizard.IWizardContainer; import org.eclipse.jface.wizard.WizardPage; import org.eclipse.swt.SWT; import org.eclipse.swt.events.ModifyEvent; import org.eclipse.swt.events.ModifyListener; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.events.SelectionListener; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Combo; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Group; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Table; import org.eclipse.swt.widgets.TableColumn; import org.eclipse.swt.widgets.TableItem; import org.eclipse.swt.widgets.Text; import org.geotools.referencing.CRS; import org.simantics.district.imports.CSVImportModel; import org.simantics.district.network.ui.DynamicComboFieldEditor; public class CSVImportWizardPage extends WizardPage { private CSVImportModel model; private Map headerIndexAndValues = new HashMap<>(); private Table headerTable; // private Button firstAsHeader; private Combo delimiterCombo; private TableColumnLayout tableColumnLayout; private Composite tableComposite; // private FileSelectionWidget wktFileSelection; // Common for vertex and edge private DynamicComboFieldEditor componentMappingSelector; private DynamicComboFieldEditor idSelector; // For vertex import private DynamicComboFieldEditor xCoordSelector; private DynamicComboFieldEditor yCoordSelector; private DynamicComboFieldEditor zValueSelector; private DynamicComboFieldEditor altElevationValueSelector; private DynamicComboFieldEditor supplyTempValueSelector; private DynamicComboFieldEditor returnTempValueSelector; private DynamicComboFieldEditor supplyPressureValueSelector; private DynamicComboFieldEditor returnPressureValueSelector; private DynamicComboFieldEditor dpSelector; private DynamicComboFieldEditor dtSelector; private DynamicComboFieldEditor heatPowerSelector; private DynamicComboFieldEditor peakPowerSelector; private DynamicComboFieldEditor regionSelector; private DynamicComboFieldEditor nominalHeadMSelector; private DynamicComboFieldEditor nominalHeadBSelector; private DynamicComboFieldEditor nominalFlowSelector; private DynamicComboFieldEditor maximumHeadMSelector; private DynamicComboFieldEditor heatLoadDsSelector; private DynamicComboFieldEditor massFlowSelector; private DynamicComboFieldEditor volFlowSelector; private DynamicComboFieldEditor velocitySelector; private DynamicComboFieldEditor flowAreaSelector; private DynamicComboFieldEditor nominalPressureLossSelector; private DynamicComboFieldEditor valvePositionSelector; private DynamicComboFieldEditor addressSelector; private DynamicComboFieldEditor lengthSelector; // For edge import private DynamicComboFieldEditor startXCoordSelector; private DynamicComboFieldEditor startYCoordSelector; private DynamicComboFieldEditor startZValueSelector; private DynamicComboFieldEditor endXCoordSelector; private DynamicComboFieldEditor endYCoordSelector; private DynamicComboFieldEditor endZValueSelector; private DynamicComboFieldEditor detailedGeometrySelector; private DynamicComboFieldEditor pipeCodeSelector; private DynamicComboFieldEditor installationYearSelector; private DynamicComboFieldEditor wallThicknessSelector; private DynamicComboFieldEditor insulationConductivitySelector; private DynamicComboFieldEditor pipeSizeDNSelector; private DynamicComboFieldEditor roughnessSelector; private DynamicComboFieldEditor structureSelector; private Text edgeConnectionPadding; private DynamicComboFieldEditor outerDiameterSelector; private DynamicComboFieldEditor diameterSelector; private DynamicComboFieldEditor nominalMassFlowSelector; private Group indexMappingGroup; private Composite composite; private Button isVertexImport; private Combo sourceCRSCombo; private DynamicComboFieldEditor edgeFlowAreaSelector; private DynamicComboFieldEditor kReturnSelector; private DynamicComboFieldEditor kSupplySelector; private DynamicComboFieldEditor tGroundSelector; protected CSVImportWizardPage(CSVImportModel model) { super("Import CSV Data"); this.model = model; setMessage("Select column index mappings"); } @Override public void createControl(Composite parent) { composite = new Composite(parent, SWT.NONE); composite.setLayout(new GridLayout(1, false)); GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(composite); Label label = new Label(composite, SWT.NONE); label.setText("Select delimiter"); delimiterCombo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY); delimiterCombo.setToolTipText("Select the delimiter that is used to separate elements in the CSV file"); String[] formats = model.getDelimiterFormats(); delimiterCombo.setItems(formats); if (formats.length > 0) delimiterCombo.select(0); delimiterCombo.addSelectionListener(new SelectionListener() { @Override public void widgetSelected(SelectionEvent e) { model.setDelimiterByLabel(delimiterCombo.getItem(delimiterCombo.getSelectionIndex())); updateHeaders(); updateCombos(); } @Override public void widgetDefaultSelected(SelectionEvent e) { widgetSelected(e); } }); // firstAsHeader = new Button(composite, SWT.CHECK); // firstAsHeader.setText("Read first row as header"); // firstAsHeader.setSelection(model.getReadFirstAsHeader()); // firstAsHeader.addSelectionListener(new SelectionListener() { // // @Override // public void widgetSelected(SelectionEvent e) { // model.setReadFirstAsHeader(firstAsHeader.getSelection()); // updateHeaders(); // updateCombos(); // } // // @Override // public void widgetDefaultSelected(SelectionEvent e) { // widgetSelected(e); // } // }); tableComposite = new Composite(composite, SWT.BORDER); tableColumnLayout = new TableColumnLayout(); tableComposite.setLayout(tableColumnLayout); label = new Label(composite, SWT.NONE); label.setText("Select source Coordinate Reference System"); sourceCRSCombo = new Combo(composite, SWT.NONE); sourceCRSCombo.setToolTipText("Select the coordinate reference system that is used in the source material for possible transformation to target coordinate reference system (EPSG:4326)"); Set codes = CRS.getSupportedCodes("EPSG"); sourceCRSCombo.setItems(codes.toArray(new String[codes.size()])); sourceCRSCombo.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { String current = sourceCRSCombo.getItem(sourceCRSCombo.getSelectionIndex()); model.setSourceCRS("EPSG:" + current); } }); sourceCRSCombo.addModifyListener(new ModifyListener() { @Override public void modifyText(ModifyEvent e) { String currentText = sourceCRSCombo.getText(); if (codes.contains(currentText)) { // Select this String[] items = sourceCRSCombo.getItems(); int i; for (i = 0; i < items.length; i++) { String item = items[i]; if (currentText.equals(item)) { break; } } if (i != 0) { sourceCRSCombo.select(i); model.setSourceCRS("EPSG:" + currentText); } else { System.err.println("this should not happen"); } } } }); // wktFileSelection = new FileSelectionWidget(composite, "WKT file", SWT.OPEN); // wktFileSelection.addListener(new FileSelectionListener() { // // @Override // public void fileSelected(FileOrDirectorySelectionWidget source, String[] filename) { // String[] selection = wktFileSelection.getFilename(); // if (selection != null && selection.length > 0) { // Path wktFile = Paths.get(selection[0]); // if (!Files.exists(wktFile)) { // setErrorMessage("File " + wktFile.toAbsolutePath() + " does not exist"); // } else { // model.setWKTFile(wktFile); // validatePageComplete(); // } // } // } // }); isVertexImport = new Button(composite, SWT.CHECK); isVertexImport.setText("File contains vertices"); isVertexImport.setToolTipText("Enable this if the file contains vertices, i.e. points"); isVertexImport.setSelection(model.isVertexImport()); isVertexImport.addSelectionListener(new SelectionListener() { @Override public void widgetSelected(SelectionEvent e) { model.setVertexImport(isVertexImport.getSelection()); updateControls(false); } @Override public void widgetDefaultSelected(SelectionEvent e) { widgetSelected(e); } }); updateControls(true); updateHeaders(); setControl(composite); final IWizardContainer container = getContainer(); if (container instanceof IPageChangeProvider) { ((IPageChangeProvider) container).addPageChangedListener(new IPageChangedListener() { @Override public void pageChanged(PageChangedEvent event) { if (isCurrentPage()) CSVImportWizardPage.this.updateControls(false); } }); } validatePageComplete(); } private void updateControls(boolean initial) { createIndexMappingGroup(); updateCombos(); if (!initial) composite.layout(true, true); } private void createIndexMappingGroup() { if (indexMappingGroup != null) indexMappingGroup.dispose(); indexMappingGroup = new Group(composite, SWT.NONE); indexMappingGroup.setText("Column index mapping"); GridDataFactory.fillDefaults().grab(true, false).span(2, 1).applyTo(indexMappingGroup); if (model.isVertexImport()) createVertexIndexMappingField(indexMappingGroup); else createEdgeIndexMappingField(indexMappingGroup); createCommonIndexMappingField(indexMappingGroup); if (!model.isVertexImport()) { Label label = new Label(indexMappingGroup, SWT.NONE); label.setText("Connection point padding"); GridDataFactory.fillDefaults().applyTo(label); edgeConnectionPadding = new Text(indexMappingGroup, SWT.BORDER); GridDataFactory.fillDefaults().applyTo(edgeConnectionPadding); edgeConnectionPadding.setText("0.0001"); // default edgeConnectionPadding.addModifyListener(new ModifyListener() { @Override public void modifyText(ModifyEvent e) { try { double padding = Double.parseDouble(edgeConnectionPadding.getText()); model.setEdgePadding(padding); } catch (NumberFormatException ee) { // ignore } } }); } } private void createCommonIndexMappingField(Group parent) { componentMappingSelector = createComboField("componentMapping", "Apros component mapping", model::setComponentMappingIndex, parent); idSelector = createComboField("id", "ID", model::setIdIndex, parent); regionSelector = createComboField("regionValue", "Region", model::setRegionIndex, parent); } private DynamicComboFieldEditor createComboField(String name, String label, Consumer setter, Group parent) { DynamicComboFieldEditor selector = new DynamicComboFieldEditor(name, label, parent); createSelectionListener(selector, setter); return selector; } private void createSelectionListener(DynamicComboFieldEditor editor, Consumer setter) { editor.addComboListener(new SelectionListener() { @Override public void widgetSelected(SelectionEvent e) { widgetDefaultSelected(e); } @Override public void widgetDefaultSelected(SelectionEvent e) { setter.accept(Integer.parseInt(editor.getValue())); validatePageComplete(); } }); } private void createVertexIndexMappingField(Group parent) { xCoordSelector = createComboField("xCoord", "X Coordinate", model::setXCoordIndex, parent); yCoordSelector = createComboField("yCoord", "Y Coordinate", model::setYCoordIndex, parent); zValueSelector = createComboField("zValue", "Z Value", model::setZCoordIndex, parent); altElevationValueSelector = createComboField("altElevation", "Alternative Elevation", model::setAltElevationIndex, parent); supplyTempValueSelector = createComboField("tempValue", "Supply Temperature value", model::setSupplyTempIndex, parent); returnTempValueSelector = createComboField("returnTempValue", "Return Temperature value", model::setReturnTempIndex, parent); supplyPressureValueSelector = createComboField("pressureValue", "Supply Pressure value", model::setSupplyPressureIndex, parent); returnPressureValueSelector = createComboField("returnPressureValue", "Return Pressure value", model::setReturnPressureIndex, parent); dpSelector = createComboField("dpValue", "Delta pressure ", model::setDeltaPressureIndex, parent); dtSelector = createComboField("dtValue", "Delta temperature ", model::setDeltaTemperatureIndex, parent); heatPowerSelector = createComboField("heatPowerValue", "Heat Power", model::setHeatPowerIndex, parent); peakPowerSelector = createComboField("peakPowerValue", "Peak Power", model::setPeakPowerIndex, parent); nominalHeadMSelector = createComboField("nominalHeadMValue", "nominalHeadM", model::setNominalHeadMIndex, parent); nominalHeadBSelector = createComboField("nominalHeadBValue", "nominalHeadB", model::setNominalHeadBIndex, parent); nominalFlowSelector = createComboField("nominalFlowValue", "nominalFlow", model::setNominalFlowIndex, parent); maximumHeadMSelector = createComboField("maximumHeadMValue", "maximumHeadM", model::setMaximumHeadMIndex, parent); heatLoadDsSelector = createComboField("heatLoadDsValue", "heatLoadDs", model::setHeatLoadDsIndex, parent); massFlowSelector = createComboField("massFlowValue", "massFlow", model::setMassFlowIndex, parent); volFlowSelector = createComboField("volFlowValue", "volFlow", model::setVolFlowIndex, parent); velocitySelector = createComboField("velocityValue", "velocity", model::setVelocityIndex, parent); flowAreaSelector = createComboField("flowAreaValue", "flowArea", model::setFlowAreaIndex, parent); nominalPressureLossSelector = createComboField("nominalPressureLossValue", "nominalPressureLoss", model::setNominalPressureLossIndex, parent); valvePositionSelector = createComboField("valvePositionSelectorValue", "valvePositionSelector", model::setValvePositionIndex, parent); addressSelector = createComboField("addressValue", "addressSelector", model::setAddressIndex, parent); } private void createEdgeIndexMappingField(Group parent) { // Composite paddingComposite = new Composite(parent, SWT.NONE); // GridLayoutFactory.fillDefaults().numColumns(2).applyTo(paddingComposite); startXCoordSelector = createComboField("startxCoord", "Start X Coordinate", model::setStartXCoordIndex, parent); startYCoordSelector = createComboField("startyCoord", "Start Y Coordinate", model::setStartYCoordIndex, parent); startZValueSelector = createComboField("startzValue", "Start Z Value", model::setStartZCoordIndex, parent); endXCoordSelector = createComboField("endxCoord", "End X Coordinate", model::setEndXCoordIndex, parent); endYCoordSelector = createComboField("endyCoord", "End Y Coordinate", model::setEndYCoordIndex, parent); endZValueSelector = createComboField("endzValue", "End Z Value", model::setEndZCoordIndex, parent); pipeCodeSelector = createComboField("pipeCodeValue", "Pipe Code", model::setPipeCodeIndex, parent); detailedGeometrySelector = createComboField("detailedGeometryValue", "Geometry", model::detailedGeometryIndex, parent); diameterSelector = createComboField("diameterValue", "Diameter value", model::setDiameterIndex, parent); outerDiameterSelector = createComboField("outerDiameterValue", "Outer Diameter value", model::setOuterDiameterIndex, parent); nominalMassFlowSelector = createComboField("nominalMassFlowValue", "Nominal Mass Flow", model::setNominalMassFlowIndex, parent); edgeFlowAreaSelector = createComboField("edgeFlowAreaValue", "Flow Area", model::setEdgeFlowAreaIndex, parent); kReturnSelector = createComboField("kReturnValue", "K Return", model::setKReturnIndex, parent); kSupplySelector = createComboField("kSupplyValue", "K Supply", model::setKSupplyIndex, parent); tGroundSelector = createComboField("tGroundValue", "Temperature Ground", model::setTGroundIndex, parent); lengthSelector = createComboField("lengthValue", "lengthSelector", model::setLengthIndex, parent); pipeSizeDNSelector = createComboField("pipeSizeDNValue", "Pipe Size DN", model::setPipeSizeDNIndex, parent); structureSelector = createComboField("structureValue", "Structure", model::setStructureIndex, parent); installationYearSelector = createComboField("installationYearValue", "Installation Year", model::setInstallationYearIndex, parent); wallThicknessSelector = createComboField("wallThicknessValue", "Wall Thickness", model::setWallThicknessIndex, parent); insulationConductivitySelector = createComboField("insulationConductivityValue", "Insulation Conductivity", model::setInsulationConductivityIndex, parent); roughnessSelector = createComboField("roughnessValue", "Roughness", model::setRoughnessIndex, parent); } private void updateCombos() { String[][] namesAndValues = new String[headerIndexAndValues.size() + 1][]; namesAndValues[0] = new String[] {"", "-1"}; int i = 1; for (Entry entry : headerIndexAndValues.entrySet()) { int key = entry.getKey(); String value = entry.getValue(); String[] nameAndValue = new String[2]; nameAndValue[0] = value; nameAndValue[1] = Integer.toString(key); namesAndValues[i++] = nameAndValue; } if (model.isVertexImport()) updateVertexCombos(namesAndValues); else updateEdgeCombos(namesAndValues); componentMappingSelector.updateCombo(namesAndValues); idSelector.updateCombo(namesAndValues); } private void updateEdgeCombos(String[][] namesAndValues) { startXCoordSelector.updateCombo(namesAndValues); endXCoordSelector.updateCombo(namesAndValues); startYCoordSelector.updateCombo(namesAndValues); endYCoordSelector.updateCombo(namesAndValues); startZValueSelector.updateCombo(namesAndValues); endZValueSelector.updateCombo(namesAndValues); pipeCodeSelector.updateCombo(namesAndValues); detailedGeometrySelector.updateCombo(namesAndValues); diameterSelector.updateCombo(namesAndValues); outerDiameterSelector.updateCombo(namesAndValues); nominalMassFlowSelector.updateCombo(namesAndValues); edgeFlowAreaSelector.updateCombo(namesAndValues); kReturnSelector.updateCombo(namesAndValues); kSupplySelector.updateCombo(namesAndValues); tGroundSelector.updateCombo(namesAndValues); lengthSelector.updateCombo(namesAndValues); pipeSizeDNSelector.updateCombo(namesAndValues); structureSelector.updateCombo(namesAndValues); installationYearSelector.updateCombo(namesAndValues); wallThicknessSelector.updateCombo(namesAndValues); insulationConductivitySelector.updateCombo(namesAndValues); roughnessSelector.updateCombo(namesAndValues); } private void updateVertexCombos(String[][] namesAndValues) { xCoordSelector.updateCombo(namesAndValues); yCoordSelector.updateCombo(namesAndValues); zValueSelector.updateCombo(namesAndValues); altElevationValueSelector.updateCombo(namesAndValues); supplyTempValueSelector.updateCombo(namesAndValues); returnTempValueSelector.updateCombo(namesAndValues); supplyPressureValueSelector.updateCombo(namesAndValues); returnPressureValueSelector.updateCombo(namesAndValues); dpSelector.updateCombo(namesAndValues); dtSelector.updateCombo(namesAndValues); heatPowerSelector.updateCombo(namesAndValues); valvePositionSelector.updateCombo(namesAndValues); nominalHeadMSelector.updateCombo(namesAndValues); nominalHeadBSelector.updateCombo(namesAndValues); nominalFlowSelector.updateCombo(namesAndValues); maximumHeadMSelector.updateCombo(namesAndValues); heatLoadDsSelector.updateCombo(namesAndValues); massFlowSelector.updateCombo(namesAndValues); volFlowSelector.updateCombo(namesAndValues); velocitySelector.updateCombo(namesAndValues); flowAreaSelector.updateCombo(namesAndValues); nominalPressureLossSelector.updateCombo(namesAndValues); addressSelector.updateCombo(namesAndValues); } private void updateHeaders() { if (headerTable != null) headerTable.dispose(); headerTable = new Table(tableComposite, SWT.NONE); headerTable.setHeaderVisible(true); headerTable.setLinesVisible(true); GridDataFactory.fillDefaults().grab(true, true).align(SWT.FILL, SWT.FILL).applyTo(tableComposite); for (int i = 0; i < headerTable.getColumns().length; i++) { TableColumn column = headerTable.getColumns()[i]; column.dispose(); } for (int i = 0; i < headerTable.getItemCount(); i++) { TableItem item = headerTable.getItem(i); item.dispose(); } headerIndexAndValues.clear(); try { List rows = model.getRows(5, false); for (int k = 0; k < rows.size(); k++) { CSVRecord row = rows.get(k); int columnCount = row.size(); for (int i = 0; i < columnCount; i++) { String value = row.get(i); if (k == 0) { TableColumn headerCol = new TableColumn(headerTable, SWT.NONE); headerCol.setText(value); tableColumnLayout.setColumnData(headerCol, new ColumnWeightData(10)); headerCol.pack(); headerIndexAndValues.put(i, value); } else { int actualK = k - 1; TableItem item; int itemCount = headerTable.getItemCount(); if (actualK >= itemCount) { item = new TableItem(headerTable, SWT.NONE); } else { item = headerTable.getItem(actualK); } item.setText(i, value); } } } } catch (IOException e) { setErrorMessage(e.getMessage()); } } protected void validatePageComplete() { if (model.isVertexImport()) setPageComplete(model.getXCoordIndex() != -1 && model.getYCoordIndex() != -1 && model.getComponentMappingIndex() != -1); else setPageComplete(model.getStartXCoordIndex() != -1 && model.getStartYCoordIndex() != -1 && model.getEndXCoordIndex() != -1 && model.getEndYCoordIndex() != -1 && model.getComponentMappingIndex() != -1); } }