private void loadData(final KettleDataFactory dataFactory, final String selectedQueryName) {
if (dataFactory == null) {
return;
}
KettleQueryEntry selectedDataSet = null;
final String[] queryNames = dataFactory.getQueryNames();
for (int i = 0; i < queryNames.length; i++) {
final String queryName = queryNames[i];
final KettleTransFromFileProducer producer =
(KettleTransFromFileProducer) dataFactory.getQuery(queryName);
final KettleQueryEntry dataSet = new KettleQueryEntry(queryName);
dataSet.setFile(producer.getTransformationFile());
dataSet.setSelectedStep(producer.getStepName());
dataSet.setArguments(producer.getDefinedArgumentNames());
dataSet.setParameters(producer.getDefinedVariableNames());
queryListModel.addElement(dataSet);
if (ObjectUtilities.equal(selectedQueryName, queryName)) {
selectedDataSet = dataSet;
}
}
queryNameList.setSelectedValue(selectedDataSet, true);
}
public KettleDataFactory performConfiguration(
DesignTimeContext context, final KettleDataFactory dataFactory, final String queryName) {
loadData(dataFactory, queryName);
if ((dataFactory == null) || (!dataFactory.queriesAreHomogeneous())) {
// allow caller to render the default dialog... we are done here
return super.performConfiguration(context, dataFactory, queryName);
} else {
try {
refreshQueryUIComponents();
if (performEdit() == false) {
return null;
}
} catch (Exception e) {
// attempt to fall back to the default dialog...
// TODO: LOG SOMETHING USEFUL HERE
return super.performConfiguration(context, dataFactory, queryName);
}
}
final KettleDataFactory kettleDataFactory = new KettleDataFactory();
kettleDataFactory.setMetadata(dataFactory.getMetaData());
for (final KettleQueryEntry queryEntry : getQueryEntries()) {
final KettleTransformationProducer producer = queryEntry.createProducer();
kettleDataFactory.setQuery(queryEntry.getName(), producer);
}
return kettleDataFactory;
}
public void actionPerformed(final ActionEvent e) {
final KettleQueryEntry kettleQueryEntry = (KettleQueryEntry) queryNameList.getSelectedValue();
final KettleTransFromFileProducer fileProducer = kettleQueryEntry.createProducer();
final KettleDataFactory dataFactory = new KettleDataFactory();
dataFactory.setQuery(kettleQueryEntry.getName(), fileProducer);
try {
DataFactoryEditorSupport.configureDataFactoryForPreview(dataFactory, designTimeContext);
final DataPreviewDialog previewDialog = new DataPreviewDialog(KettleDataSourceDialog.this);
final KettlePreviewWorker worker =
new KettlePreviewWorker(dataFactory, kettleQueryEntry.getName());
previewDialog.showData(worker);
final ReportDataFactoryException factoryException = worker.getException();
if (factoryException != null) {
ExceptionDialog.showExceptionDialog(
KettleDataSourceDialog.this,
Messages.getString("KettleDataSourceDialog.PreviewError.Title"),
Messages.getString("KettleDataSourceDialog.PreviewError.Message"),
factoryException);
}
} catch (Exception ex) {
ExceptionDialog.showExceptionDialog(
KettleDataSourceDialog.this,
Messages.getString("KettleDataSourceDialog.PreviewError.Title"),
Messages.getString("KettleDataSourceDialog.PreviewError.Message"),
ex);
}
}
public void valueChanged(final ListSelectionEvent aEvt) {
final KettleQueryEntry queryEntry = (KettleQueryEntry) queryNameList.getSelectedValue();
final Object selectedValue = stepsList.getSelectedValue();
if (selectedValue instanceof StepMeta) {
final StepMeta stepMeta = (StepMeta) selectedValue;
queryEntry.setSelectedStep(stepMeta.getName());
}
}
public void valueChanged(final ListSelectionEvent e) {
final Object value = queryNameList.getSelectedValue();
if (value == null) {
nameTextField.setEnabled(false);
fileTextField.setEnabled(false);
stepsList.setEnabled(false);
editParameterAction.setEnabled(false);
return;
}
inUpdateFromList = true;
nameTextField.setEnabled(true);
fileTextField.setEnabled(true);
final AbstractReportDefinition report = designTimeContext.getReport();
final MasterReport masterReport = DesignTimeUtil.getMasterReport(report);
final ResourceKey contentBase;
if (masterReport == null) {
contentBase = null;
} else {
contentBase = masterReport.getContentBase();
}
try {
final KettleQueryEntry selectedQuery = (KettleQueryEntry) value;
fileTextField.setText(selectedQuery.getFile());
nameTextField.setText(selectedQuery.getName());
final StepMeta[] data = selectedQuery.getSteps(report.getResourceManager(), contentBase);
stepsList.setListData(data);
final String selectedStepName = selectedQuery.getSelectedStep();
if (selectedStepName != null) {
for (int i = 0; i < data.length; i++) {
final StepMeta stepMeta = data[i];
if (selectedStepName.equals(stepMeta.getName())) {
stepsList.setSelectedValue(stepMeta, true);
break;
}
}
}
stepsList.setEnabled(true);
editParameterAction.setEnabled(true);
} catch (ReportDataFactoryException rdfe) {
logger.warn("Non-critical failure while executing the query", rdfe);
stepsList.setEnabled(false);
editParameterAction.setEnabled(false);
} catch (Exception e1) {
designTimeContext.error(e1);
stepsList.setEnabled(false);
editParameterAction.setEnabled(false);
} catch (Throwable t1) {
designTimeContext.error(new StackableRuntimeException("Fatal error", t1));
stepsList.setEnabled(false);
editParameterAction.setEnabled(false);
} finally {
inUpdateFromList = false;
}
}
private void update() {
if (inUpdateFromList) {
return;
}
final String queryName = nameTextField.getText();
final KettleQueryEntry selectedQuery = (KettleQueryEntry) queryNameList.getSelectedValue();
selectedQuery.setName(queryName);
queryNameList.repaint();
}
@Override
protected boolean validateInputs(boolean onConfirm) {
boolean valid = true;
for (final KettleQueryEntry queryEntry : getQueryEntries()) {
valid = queryEntry.validate();
if (!valid) {
break;
}
}
return valid && super.validateInputs(onConfirm);
}
public KettleDataFactory performConfiguration(
final KettleDataFactory dataFactory, final String queryName) {
queryListModel.clear();
loadData(dataFactory, queryName);
if (performEdit() == false) {
return null;
}
final KettleDataFactory kettleDataFactory = new KettleDataFactory();
for (int i = 0; i < queryListModel.getSize(); i++) {
final KettleQueryEntry queryEntry = (KettleQueryEntry) queryListModel.getElementAt(i);
final KettleTransFromFileProducer producer = queryEntry.createProducer();
kettleDataFactory.setQuery(queryEntry.getName(), producer);
}
return kettleDataFactory;
}
public void actionPerformed(final ActionEvent e) {
final FileFilter[] fileFilters =
new FileFilter[] {
new FilesystemFilter(
new String[] {".ktr"},
Messages.getString("KettleDataSourceDialog.KtrFileDescription") + " (*.ktr)",
true)
};
final File reportContextFile = DesignTimeUtil.getContextAsFile(designTimeContext.getReport());
final CommonFileChooser fileChooser =
FileChooserService.getInstance().getFileChooser("kettle");
final String fileText = fileTextField.getText();
if (StringUtils.isEmpty(fileText) == false) {
if (reportContextFile != null) {
fileChooser.setSelectedFile(
new File(reportContextFile.getParentFile(), fileTextField.getText()));
} else {
fileChooser.setSelectedFile(new File(fileTextField.getText()));
}
}
fileChooser.setFilters(fileFilters);
if (fileChooser.showDialog(KettleDataSourceDialog.this, JFileChooser.OPEN_DIALOG) == false) {
return;
}
final File file = fileChooser.getSelectedFile();
if (file == null) {
return;
}
final String path;
if (reportContextFile != null) {
path =
IOUtils.getInstance()
.createRelativePath(file.getPath(), reportContextFile.getAbsolutePath());
} else {
path = file.getPath();
}
final KettleQueryEntry queryEntry = (KettleQueryEntry) queryNameList.getSelectedValue();
queryEntry.setFile(path);
fileTextField.setText(path);
}
public void actionPerformed(final ActionEvent e) {
final HashSet<String> names = new HashSet<String>();
for (int i = 0; i < queryListModel.getSize(); i++) {
final KettleQueryEntry o = (KettleQueryEntry) queryListModel.getElementAt(i);
names.add(o.getName());
}
String queryName = Messages.getString("KettleDataSourceDialog.Query");
for (int i = 1; i < 1000; ++i) {
final String newQuery = Messages.getString("KettleDataSourceDialog.Query") + " " + i;
if (names.contains(newQuery) == false) {
queryName = newQuery;
break;
}
}
final KettleQueryEntry newQuery = new KettleQueryEntry(queryName);
queryListModel.addElement(newQuery);
queryNameList.setSelectedValue(newQuery, true);
}
/** Invoked when an action occurs. */
public void actionPerformed(final ActionEvent e) {
final KettleQueryEntry queryEntry = (KettleQueryEntry) queryNameList.getSelectedValue();
if (queryEntry == null) {
return;
}
final AbstractReportDefinition report = designTimeContext.getReport();
final MasterReport masterReport = DesignTimeUtil.getMasterReport(report);
final ResourceKey contentBase;
if (masterReport == null) {
contentBase = null;
} else {
contentBase = masterReport.getContentBase();
}
try {
final ParameterEditorDialog dialog = new ParameterEditorDialog(KettleDataSourceDialog.this);
final String[] reportFields = designTimeContext.getDataSchemaModel().getColumnNames();
final ParameterEditorDialog.EditResult editResult =
dialog.performEdit(
queryEntry.getArguments(),
queryEntry.getParameters(),
reportFields,
queryEntry.getDeclaredParameters(report.getResourceManager(), contentBase));
if (editResult == null) {
return;
}
queryEntry.setArguments(editResult.getArgumentNames());
queryEntry.setParameters(editResult.getParameterMappings());
} catch (Exception e1) {
designTimeContext.error(e1);
} catch (Throwable t1) {
designTimeContext.error(new StackableRuntimeException("Fatal error", t1));
}
}
