mirror of
https://github.com/Kingsrook/qqq.git
synced 2025-07-18 05:01:07 +00:00
Moving qqq-middleware-picocli into its own subdir
This commit is contained in:
@ -0,0 +1,87 @@
|
||||
/*
|
||||
* QQQ - Low-code Application Framework for Engineers.
|
||||
* Copyright (C) 2021-2022. Kingsrook, LLC
|
||||
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
|
||||
* contact@kingsrook.com
|
||||
* https://github.com/Kingsrook/
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package com.kingsrook.qqq.frontend.picocli;
|
||||
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Scanner;
|
||||
import com.kingsrook.qqq.backend.core.actions.processes.QProcessCallback;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
|
||||
import picocli.CommandLine;
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Define how a PicoCLI process gets data back to a QProcess.
|
||||
*******************************************************************************/
|
||||
public class PicoCliProcessCallback implements QProcessCallback
|
||||
{
|
||||
private final CommandLine commandLine;
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Constructor that takes the picocli CommandLine object
|
||||
*******************************************************************************/
|
||||
public PicoCliProcessCallback(CommandLine commandLine)
|
||||
{
|
||||
this.commandLine = commandLine;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Get the filter query for this callback.
|
||||
*******************************************************************************/
|
||||
@Override
|
||||
public QQueryFilter getQueryFilter()
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Get the field values for this callback.
|
||||
*******************************************************************************/
|
||||
@Override
|
||||
public Map<String, Serializable> getFieldValues(List<QFieldMetaData> fields)
|
||||
{
|
||||
Map<String, Serializable> rs = new HashMap<>();
|
||||
final Scanner scanner = new Scanner(System.in);
|
||||
|
||||
///////////////////////////////////
|
||||
// todo - only if "interactive?" //
|
||||
///////////////////////////////////
|
||||
for(QFieldMetaData field : fields)
|
||||
{
|
||||
commandLine.getOut().println("Please supply a value for the field: [" + field.getLabel() + "]:");
|
||||
rs.put(field.getName(), scanner.nextLine());
|
||||
}
|
||||
|
||||
return (rs);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,417 @@
|
||||
/*
|
||||
* QQQ - Low-code Application Framework for Engineers.
|
||||
* Copyright (C) 2021-2022. Kingsrook, LLC
|
||||
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
|
||||
* contact@kingsrook.com
|
||||
* https://github.com/Kingsrook/
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package com.kingsrook.qqq.frontend.picocli;
|
||||
|
||||
|
||||
import java.math.BigDecimal;
|
||||
import java.time.LocalDate;
|
||||
import java.time.LocalDateTime;
|
||||
import java.util.ArrayList;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
|
||||
import com.kingsrook.qqq.backend.core.utils.CollectionUtils;
|
||||
import com.kingsrook.qqq.backend.core.utils.StringUtils;
|
||||
import picocli.CommandLine;
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Helper class for QPicCliImplementation to build the Command
|
||||
**
|
||||
*******************************************************************************/
|
||||
public class QCommandBuilder
|
||||
{
|
||||
private final QInstance qInstance;
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Constructor.
|
||||
**
|
||||
*******************************************************************************/
|
||||
public QCommandBuilder(QInstance qInstance)
|
||||
{
|
||||
this.qInstance = qInstance;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
CommandLine.Model.CommandSpec buildCommandSpec(String topCommandName)
|
||||
{
|
||||
//////////////////////////////////
|
||||
// define the top-level command //
|
||||
//////////////////////////////////
|
||||
CommandLine.Model.CommandSpec topCommandSpec = CommandLine.Model.CommandSpec.create();
|
||||
topCommandSpec.name(topCommandName);
|
||||
topCommandSpec.version(topCommandName + " v1.0"); // todo... uh?
|
||||
topCommandSpec.mixinStandardHelpOptions(true); // usageHelp and versionHelp options
|
||||
topCommandSpec.addOption(CommandLine.Model.OptionSpec.builder("-m", "--meta-data")
|
||||
.type(boolean.class)
|
||||
.description("Output the meta-data for this CLI")
|
||||
.build());
|
||||
|
||||
/////////////////////////////////////
|
||||
// add each table as a sub-command //
|
||||
/////////////////////////////////////
|
||||
qInstance.getTables().keySet().stream().sorted().forEach(tableName ->
|
||||
{
|
||||
QTableMetaData table = qInstance.getTable(tableName);
|
||||
|
||||
CommandLine.Model.CommandSpec tableCommand = CommandLine.Model.CommandSpec.create();
|
||||
topCommandSpec.addSubcommand(table.getName(), tableCommand);
|
||||
|
||||
///////////////////////////////////////////////////
|
||||
// add table-specific sub-commands for the table //
|
||||
///////////////////////////////////////////////////
|
||||
tableCommand.addSubcommand("meta-data", defineMetaDataCommand(table));
|
||||
tableCommand.addSubcommand("count", defineCountCommand(table));
|
||||
tableCommand.addSubcommand("get", defineGetCommand(table));
|
||||
tableCommand.addSubcommand("query", defineQueryCommand(table));
|
||||
tableCommand.addSubcommand("insert", defineInsertCommand(table));
|
||||
tableCommand.addSubcommand("update", defineUpdateCommand(table));
|
||||
tableCommand.addSubcommand("delete", defineDeleteCommand(table));
|
||||
tableCommand.addSubcommand("export", defineExportCommand(table));
|
||||
|
||||
List<QProcessMetaData> processes = qInstance.getProcessesForTable(tableName);
|
||||
if(CollectionUtils.nullSafeHasContents(processes))
|
||||
{
|
||||
tableCommand.addSubcommand("process", defineProcessesCommand(processes));
|
||||
}
|
||||
});
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
// add all orphan processes (e.g., ones without tables) to the top-level //
|
||||
///////////////////////////////////////////////////////////////////////////
|
||||
List<QProcessMetaData> orphanProcesses = new ArrayList<>();
|
||||
for(QProcessMetaData process : qInstance.getProcesses().values())
|
||||
{
|
||||
if(!StringUtils.hasContent(process.getTableName()))
|
||||
{
|
||||
orphanProcesses.add(process);
|
||||
}
|
||||
}
|
||||
|
||||
if(!orphanProcesses.isEmpty())
|
||||
{
|
||||
topCommandSpec.addSubcommand("processes", defineProcessesCommand(orphanProcesses));
|
||||
}
|
||||
|
||||
return topCommandSpec;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineMetaDataCommand(QTableMetaData table)
|
||||
{
|
||||
return CommandLine.Model.CommandSpec.create();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineQueryCommand(QTableMetaData table)
|
||||
{
|
||||
CommandLine.Model.CommandSpec queryCommand = CommandLine.Model.CommandSpec.create();
|
||||
queryCommand.addOption(CommandLine.Model.OptionSpec.builder("-l", "--limit")
|
||||
.type(int.class)
|
||||
.build());
|
||||
queryCommand.addOption(CommandLine.Model.OptionSpec.builder("-s", "--skip")
|
||||
.type(int.class)
|
||||
.build());
|
||||
queryCommand.addOption(CommandLine.Model.OptionSpec.builder("-c", "--criteria")
|
||||
.type(String[].class)
|
||||
.build());
|
||||
|
||||
// todo - add the fields as explicit params?
|
||||
|
||||
return queryCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineExportCommand(QTableMetaData table)
|
||||
{
|
||||
CommandLine.Model.CommandSpec exportCommand = CommandLine.Model.CommandSpec.create();
|
||||
exportCommand.addOption(CommandLine.Model.OptionSpec.builder("-f", "--filename")
|
||||
.type(String.class)
|
||||
.description("File name (including path) to write to. File extension will be used to determine the report format. Supported formats are: csv, xlsx.")
|
||||
.required(true)
|
||||
.build());
|
||||
exportCommand.addOption(CommandLine.Model.OptionSpec.builder("-e", "--fieldNames")
|
||||
.type(String.class)
|
||||
.description("Comma-separated list of field names (e.g., from table meta-data) to include in the export. If not given, then all fields in the table are included.")
|
||||
.build());
|
||||
exportCommand.addOption(CommandLine.Model.OptionSpec.builder("-l", "--limit")
|
||||
.type(int.class)
|
||||
.description("Optional limit on the max number of records to include in the export.")
|
||||
.build());
|
||||
addCriteriaOption(exportCommand);
|
||||
|
||||
// todo - add the fields as explicit params?
|
||||
|
||||
return exportCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** add the standard '--criteria' option
|
||||
*******************************************************************************/
|
||||
private void addCriteriaOption(CommandLine.Model.CommandSpec commandSpec)
|
||||
{
|
||||
commandSpec.addOption(CommandLine.Model.OptionSpec.builder("-c", "--criteria")
|
||||
.type(String[].class)
|
||||
.description("""
|
||||
Query filter criteria. May be given multiple times.
|
||||
Use format: "$fieldName $operator $value".
|
||||
e.g., "id EQUALS 42\"""")
|
||||
.build());
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private void addPrimaryKeyOrKeysOption(CommandLine.Model.CommandSpec updateCommand, String verbForDescription)
|
||||
{
|
||||
updateCommand.addOption(CommandLine.Model.OptionSpec.builder("--primaryKey")
|
||||
// type(getClassForField(primaryKeyField))
|
||||
.type(String.class) // todo - mmm, better as picocli's "compound" thing, w/ the actual pkey's type?
|
||||
.description("""
|
||||
Primary Key(s) for the records to %s.
|
||||
May provide multiple values, separated by commas""".formatted(verbForDescription))
|
||||
.build());
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineGetCommand(QTableMetaData table)
|
||||
{
|
||||
CommandLine.Model.CommandSpec getCommand = CommandLine.Model.CommandSpec.create();
|
||||
getCommand.addPositional(CommandLine.Model.PositionalParamSpec.builder()
|
||||
.index("0")
|
||||
// .type(String.class) // todo - mmm, better as picocli's "compound" thing, w/ the actual pkey's type?
|
||||
.description("Primary key value from the table")
|
||||
.build());
|
||||
|
||||
return getCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineCountCommand(QTableMetaData table)
|
||||
{
|
||||
CommandLine.Model.CommandSpec countCommand = CommandLine.Model.CommandSpec.create();
|
||||
addCriteriaOption(countCommand);
|
||||
|
||||
// todo - add the fields as explicit params?
|
||||
|
||||
return countCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineUpdateCommand(QTableMetaData table)
|
||||
{
|
||||
CommandLine.Model.CommandSpec updateCommand = CommandLine.Model.CommandSpec.create();
|
||||
|
||||
/*
|
||||
todo - future may accept files, similar to (bulk) insert
|
||||
updateCommand.addOption(CommandLine.Model.OptionSpec.builder("--jsonBody")
|
||||
.type(String.class)
|
||||
.build());
|
||||
|
||||
updateCommand.addOption(CommandLine.Model.OptionSpec.builder("--jsonFile")
|
||||
.type(String.class)
|
||||
.build());
|
||||
|
||||
updateCommand.addOption(CommandLine.Model.OptionSpec.builder("--csvFile")
|
||||
.type(String.class)
|
||||
.build());
|
||||
|
||||
updateCommand.addOption(CommandLine.Model.OptionSpec.builder("--mapping")
|
||||
.type(String.class)
|
||||
.build());
|
||||
*/
|
||||
|
||||
QFieldMetaData primaryKeyField = null;
|
||||
if(table.getPrimaryKeyField() != null)
|
||||
{
|
||||
primaryKeyField = table.getField(table.getPrimaryKeyField());
|
||||
addPrimaryKeyOrKeysOption(updateCommand, "update");
|
||||
}
|
||||
|
||||
for(QFieldMetaData field : table.getFields().values())
|
||||
{
|
||||
if(!field.equals(primaryKeyField))
|
||||
{
|
||||
updateCommand.addOption(CommandLine.Model.OptionSpec.builder("--field-" + field.getName())
|
||||
.type(getClassForField(field))
|
||||
.description("""
|
||||
Value to set for the field %s""".formatted(field.getName()))
|
||||
.build());
|
||||
}
|
||||
}
|
||||
|
||||
addCriteriaOption(updateCommand);
|
||||
|
||||
return updateCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineInsertCommand(QTableMetaData table)
|
||||
{
|
||||
CommandLine.Model.CommandSpec insertCommand = CommandLine.Model.CommandSpec.create();
|
||||
|
||||
insertCommand.addOption(CommandLine.Model.OptionSpec.builder("--jsonBody")
|
||||
.type(String.class)
|
||||
.build());
|
||||
|
||||
insertCommand.addOption(CommandLine.Model.OptionSpec.builder("--jsonFile")
|
||||
.type(String.class)
|
||||
.build());
|
||||
|
||||
insertCommand.addOption(CommandLine.Model.OptionSpec.builder("--csvFile")
|
||||
.type(String.class)
|
||||
.build());
|
||||
|
||||
insertCommand.addOption(CommandLine.Model.OptionSpec.builder("--mapping")
|
||||
.type(String.class)
|
||||
.build());
|
||||
|
||||
for(QFieldMetaData field : table.getFields().values())
|
||||
{
|
||||
insertCommand.addOption(CommandLine.Model.OptionSpec.builder("--field-" + field.getName())
|
||||
.type(getClassForField(field))
|
||||
.build());
|
||||
}
|
||||
return insertCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineDeleteCommand(QTableMetaData table)
|
||||
{
|
||||
CommandLine.Model.CommandSpec deleteCommand = CommandLine.Model.CommandSpec.create();
|
||||
|
||||
deleteCommand.addOption(CommandLine.Model.OptionSpec.builder("--primaryKey")
|
||||
.type(String.class) // todo - mmm, better as picocli's "compound" thing, w/ the actual pkey's type?
|
||||
.build());
|
||||
|
||||
addCriteriaOption(deleteCommand);
|
||||
|
||||
return deleteCommand;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private CommandLine.Model.CommandSpec defineProcessesCommand(List<QProcessMetaData> processes)
|
||||
{
|
||||
CommandLine.Model.CommandSpec processesCommand = CommandLine.Model.CommandSpec.create();
|
||||
|
||||
for(QProcessMetaData process : processes)
|
||||
{
|
||||
///////////////////////////////////////////
|
||||
// add the sub-command to run the proces //
|
||||
///////////////////////////////////////////
|
||||
CommandLine.Model.CommandSpec processCommand = CommandLine.Model.CommandSpec.create();
|
||||
processesCommand.addSubcommand(process.getName(), processCommand);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
// add all (distinct, by name) input fields to the command as --field-* options //
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
Map<String, QFieldMetaData> inputFieldMap = new LinkedHashMap<>();
|
||||
for(QFieldMetaData inputField : process.getInputFields())
|
||||
{
|
||||
inputFieldMap.put(inputField.getName(), inputField);
|
||||
}
|
||||
|
||||
for(QFieldMetaData field : inputFieldMap.values())
|
||||
{
|
||||
processCommand.addOption(CommandLine.Model.OptionSpec.builder("--field-" + field.getName())
|
||||
.type(getClassForField(field))
|
||||
.build());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return (processesCommand);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
@SuppressWarnings("checkstyle:Indentation")
|
||||
private Class<?> getClassForField(QFieldMetaData field)
|
||||
{
|
||||
// @formatter:off // IJ can't do new-style switch correctly yet...
|
||||
return switch(field.getType())
|
||||
{
|
||||
case STRING, TEXT, HTML, PASSWORD -> String.class;
|
||||
case INTEGER -> Integer.class;
|
||||
case DECIMAL -> BigDecimal.class;
|
||||
case DATE -> LocalDate.class;
|
||||
// case TIME -> LocalTime.class;
|
||||
case DATE_TIME -> LocalDateTime.class;
|
||||
case BLOB -> byte[].class;
|
||||
};
|
||||
// @formatter:on
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,951 @@
|
||||
/*
|
||||
* QQQ - Low-code Application Framework for Engineers.
|
||||
* Copyright (C) 2021-2022. Kingsrook, LLC
|
||||
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
|
||||
* contact@kingsrook.com
|
||||
* https://github.com/Kingsrook/
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package com.kingsrook.qqq.frontend.picocli;
|
||||
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import java.io.PrintStream;
|
||||
import java.io.PrintWriter;
|
||||
import java.io.Serializable;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import com.kingsrook.qqq.backend.core.actions.metadata.MetaDataAction;
|
||||
import com.kingsrook.qqq.backend.core.actions.metadata.TableMetaDataAction;
|
||||
import com.kingsrook.qqq.backend.core.actions.processes.RunProcessAction;
|
||||
import com.kingsrook.qqq.backend.core.actions.reporting.ReportAction;
|
||||
import com.kingsrook.qqq.backend.core.actions.tables.CountAction;
|
||||
import com.kingsrook.qqq.backend.core.actions.tables.DeleteAction;
|
||||
import com.kingsrook.qqq.backend.core.actions.tables.InsertAction;
|
||||
import com.kingsrook.qqq.backend.core.actions.tables.QueryAction;
|
||||
import com.kingsrook.qqq.backend.core.actions.tables.UpdateAction;
|
||||
import com.kingsrook.qqq.backend.core.adapters.CsvToQRecordAdapter;
|
||||
import com.kingsrook.qqq.backend.core.adapters.JsonToQFieldMappingAdapter;
|
||||
import com.kingsrook.qqq.backend.core.adapters.JsonToQRecordAdapter;
|
||||
import com.kingsrook.qqq.backend.core.adapters.QInstanceAdapter;
|
||||
import com.kingsrook.qqq.backend.core.exceptions.QAuthenticationException;
|
||||
import com.kingsrook.qqq.backend.core.exceptions.QException;
|
||||
import com.kingsrook.qqq.backend.core.exceptions.QModuleDispatchException;
|
||||
import com.kingsrook.qqq.backend.core.exceptions.QUserFacingException;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.metadata.MetaDataOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.metadata.TableMetaDataInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.metadata.TableMetaDataOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.processes.RunProcessOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportFormat;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.reporting.ReportOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.shared.mapping.AbstractQFieldMapping;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.shared.mapping.QKeyBasedFieldMapping;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.count.CountOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.delete.DeleteOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.insert.InsertOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QCriteriaOperator;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QFilterCriteria;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QQueryFilter;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.query.QueryOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateInput;
|
||||
import com.kingsrook.qqq.backend.core.model.actions.tables.update.UpdateOutput;
|
||||
import com.kingsrook.qqq.backend.core.model.data.QRecord;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.session.QSession;
|
||||
import com.kingsrook.qqq.backend.core.modules.authentication.Auth0AuthenticationModule;
|
||||
import com.kingsrook.qqq.backend.core.modules.authentication.QAuthenticationModuleDispatcher;
|
||||
import com.kingsrook.qqq.backend.core.modules.authentication.QAuthenticationModuleInterface;
|
||||
import com.kingsrook.qqq.backend.core.utils.JsonUtils;
|
||||
import com.kingsrook.qqq.backend.core.utils.StringUtils;
|
||||
import io.github.cdimascio.dotenv.Dotenv;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.apache.logging.log4j.core.config.Configurator;
|
||||
import org.jline.reader.LineReader;
|
||||
import org.jline.reader.LineReaderBuilder;
|
||||
import org.jline.utils.Log;
|
||||
import picocli.CommandLine;
|
||||
import picocli.CommandLine.Model.CommandSpec;
|
||||
import picocli.CommandLine.Model.OptionSpec;
|
||||
import picocli.CommandLine.ParameterException;
|
||||
import picocli.CommandLine.ParseResult;
|
||||
import picocli.CommandLine.UnmatchedArgumentException;
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** QQQ PicoCLI implementation. Given a QInstance, produces an entire CLI
|
||||
** for working with all tables in that instance.
|
||||
**
|
||||
** Note: Please do not use System.out or .err here -- rather, use the CommandLine
|
||||
** object's out & err members - so the unit test can see the output!
|
||||
**
|
||||
*******************************************************************************/
|
||||
public class QPicoCliImplementation
|
||||
{
|
||||
public static final int DEFAULT_QUERY_LIMIT = 20;
|
||||
|
||||
private static QInstance qInstance;
|
||||
private static QSession session;
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
public static void main(String[] args) throws IOException
|
||||
{
|
||||
// todo - authentication
|
||||
// qInstance.addBackend(QMetaDataProvider.getQBackend());
|
||||
|
||||
// parse args to look up metaData and prime instance
|
||||
if(args.length > 0 && args[0].startsWith("--qInstanceJsonFile="))
|
||||
{
|
||||
String filePath = args[0].replaceFirst("--.*=", "");
|
||||
String qInstanceJson = FileUtils.readFileToString(new File(filePath));
|
||||
qInstance = new QInstanceAdapter().jsonToQInstanceIncludingBackends(qInstanceJson);
|
||||
|
||||
String[] subArgs = Arrays.copyOfRange(args, 1, args.length);
|
||||
|
||||
QPicoCliImplementation qPicoCliImplementation = new QPicoCliImplementation(qInstance);
|
||||
int exitCode = qPicoCliImplementation.runCli("qapi", subArgs);
|
||||
System.exit(exitCode);
|
||||
}
|
||||
else
|
||||
{
|
||||
System.err.println("To run this main class directly, you must specify: --qInstanceJsonFile=path/to/qInstance.json");
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
public QPicoCliImplementation(QInstance qInstance)
|
||||
{
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// use the qqq-picocli log4j config, less the system property log4j.configurationFile was set by the runner //
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
if(System.getProperty("log4j.configurationFile") == null)
|
||||
{
|
||||
Configurator.initialize(null, "qqq-picocli-log4j2.xml");
|
||||
}
|
||||
|
||||
QPicoCliImplementation.qInstance = qInstance;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Driver method that uses System out & err streams.
|
||||
*
|
||||
*******************************************************************************/
|
||||
public int runCli(String name, String[] args)
|
||||
{
|
||||
return (runCli(name, args, System.out, System.err));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Actual driver methods that takes streams as params.
|
||||
*
|
||||
** examples - todo, make docs complete!
|
||||
** my-app-cli [--all] [--format=]
|
||||
** my-app-cli $table meta-data [--format=]
|
||||
** my-app-cli $table query [--filterId=]|[--filter=]|[--criteria=...]
|
||||
** my-app-cli $table get (--primaryKey=|--$uc=...)
|
||||
** my-app-cli $table delete (--primaryKey=|--$uc=...)
|
||||
** my-app-cli $table insert (--body=|--$field=...)
|
||||
** my-app-cli $table update (--primaryKey=|--$uc=...) (--body=|--$field=...)
|
||||
** my-app-cli $table process $process ...
|
||||
**
|
||||
*******************************************************************************/
|
||||
public int runCli(String name, String[] args, PrintStream out, PrintStream err)
|
||||
{
|
||||
CommandSpec topCommandSpec = new QCommandBuilder(qInstance).buildCommandSpec(name);
|
||||
|
||||
CommandLine commandLine = new CommandLine(topCommandSpec);
|
||||
commandLine.setOut(new PrintWriter(out, true));
|
||||
commandLine.setErr(new PrintWriter(err, true));
|
||||
|
||||
try
|
||||
{
|
||||
setupSession(args);
|
||||
// todo - think about, do some tables get turned off based on authentication?
|
||||
|
||||
ParseResult parseResult = commandLine.parseArgs(args);
|
||||
|
||||
///////////////////////////////////////////
|
||||
// Did user request usage help (--help)? //
|
||||
///////////////////////////////////////////
|
||||
if(commandLine.isUsageHelpRequested())
|
||||
{
|
||||
commandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
////////////////////////////////////////////////
|
||||
// Did user request version help (--version)? //
|
||||
////////////////////////////////////////////////
|
||||
else if(commandLine.isVersionHelpRequested())
|
||||
{
|
||||
commandLine.printVersionHelp(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnVersionHelp();
|
||||
}
|
||||
|
||||
///////////////////////////
|
||||
// else, run the command //
|
||||
///////////////////////////
|
||||
return run(commandLine, parseResult);
|
||||
}
|
||||
catch(ParameterException ex)
|
||||
{
|
||||
//////////////////////////////////////////////////
|
||||
// handle command-line/param parsing exceptions //
|
||||
//////////////////////////////////////////////////
|
||||
commandLine.getErr().println(ex.getMessage());
|
||||
UnmatchedArgumentException.printSuggestions(ex, commandLine.getErr());
|
||||
ex.getCommandLine().usage(commandLine.getErr());
|
||||
return commandLine.getCommandSpec().exitCodeOnInvalidInput();
|
||||
}
|
||||
catch(Exception ex)
|
||||
{
|
||||
///////////////////////////////////////////
|
||||
// handle exceptions from business logic //
|
||||
///////////////////////////////////////////
|
||||
ex.printStackTrace();
|
||||
commandLine.getErr().println("Error: " + ex.getMessage());
|
||||
return (commandLine.getCommandSpec().exitCodeOnExecutionException());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private static Optional<Dotenv> loadDotEnv()
|
||||
{
|
||||
Optional<Dotenv> dotenvOptional = Optional.empty();
|
||||
try
|
||||
{
|
||||
dotenvOptional = Optional.of(Dotenv.configure().load());
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
Log.info("No session information found in environment");
|
||||
}
|
||||
|
||||
return (dotenvOptional);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private static void setupSession(String[] args) throws QModuleDispatchException, QAuthenticationException
|
||||
{
|
||||
QAuthenticationModuleDispatcher qAuthenticationModuleDispatcher = new QAuthenticationModuleDispatcher();
|
||||
QAuthenticationModuleInterface authenticationModule = qAuthenticationModuleDispatcher.getQModule(qInstance.getAuthentication());
|
||||
|
||||
try
|
||||
{
|
||||
////////////////////////////////////
|
||||
// look for .env environment file //
|
||||
////////////////////////////////////
|
||||
String sessionId = null;
|
||||
Optional<Dotenv> dotenv = loadDotEnv();
|
||||
if(dotenv.isPresent())
|
||||
{
|
||||
sessionId = dotenv.get().get("SESSION_ID");
|
||||
}
|
||||
|
||||
Map<String, String> authenticationContext = new HashMap<>();
|
||||
if(sessionId == null && authenticationModule instanceof Auth0AuthenticationModule)
|
||||
{
|
||||
LineReader lr = LineReaderBuilder.builder().build();
|
||||
String tokenId = lr.readLine("Create a .env file with the contents of the Auth0 JWT Id Token in the variable 'SESSION_ID': \nPress enter once complete...");
|
||||
dotenv = loadDotEnv();
|
||||
if(dotenv.isPresent())
|
||||
{
|
||||
sessionId = dotenv.get().get("SESSION_ID");
|
||||
}
|
||||
}
|
||||
|
||||
authenticationContext.put("sessionId", sessionId);
|
||||
|
||||
// todo - does this need some per-provider logic actually? mmm...
|
||||
session = authenticationModule.createSession(qInstance, authenticationContext);
|
||||
}
|
||||
catch(QAuthenticationException qae)
|
||||
{
|
||||
throw (qae);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int run(CommandLine commandLine, ParseResult parseResult) throws QException
|
||||
{
|
||||
if(!parseResult.hasSubcommand())
|
||||
{
|
||||
return runTopLevelCommand(commandLine, parseResult);
|
||||
}
|
||||
else
|
||||
{
|
||||
ParseResult subParseResult = parseResult.subcommand();
|
||||
String subCommandName = subParseResult.commandSpec().name();
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get(subCommandName);
|
||||
switch(subCommandName)
|
||||
{
|
||||
case "processes":
|
||||
{
|
||||
return runProcessCommand(subCommandLine, subParseResult);
|
||||
}
|
||||
default:
|
||||
{
|
||||
/////////////////////////////////////////////////////////
|
||||
// by default, assume the command here is a table name //
|
||||
/////////////////////////////////////////////////////////
|
||||
return runTableLevelCommand(subCommandLine, subParseResult);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableLevelCommand(CommandLine commandLine, ParseResult tableParseResult) throws QException
|
||||
{
|
||||
String tableName = tableParseResult.commandSpec().name();
|
||||
|
||||
if(tableParseResult.hasSubcommand())
|
||||
{
|
||||
ParseResult subParseResult = tableParseResult.subcommand();
|
||||
String subCommandName = subParseResult.commandSpec().name();
|
||||
switch(subCommandName)
|
||||
{
|
||||
case "meta-data":
|
||||
{
|
||||
return runTableMetaData(commandLine, tableName, subParseResult);
|
||||
}
|
||||
case "count":
|
||||
{
|
||||
return runTableCount(commandLine, tableName, subParseResult);
|
||||
}
|
||||
case "get":
|
||||
{
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get(subCommandName);
|
||||
return runTableGet(commandLine, tableName, subParseResult, subCommandLine);
|
||||
}
|
||||
case "query":
|
||||
{
|
||||
return runTableQuery(commandLine, tableName, subParseResult);
|
||||
}
|
||||
case "export":
|
||||
{
|
||||
return runTableExport(commandLine, tableName, subParseResult);
|
||||
}
|
||||
case "insert":
|
||||
{
|
||||
return runTableInsert(commandLine, tableName, subParseResult);
|
||||
}
|
||||
case "update":
|
||||
{
|
||||
return runTableUpdate(commandLine, tableName, subParseResult);
|
||||
}
|
||||
case "delete":
|
||||
{
|
||||
return runTableDelete(commandLine, tableName, subParseResult);
|
||||
}
|
||||
case "process":
|
||||
{
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get(subCommandName);
|
||||
return runProcessCommand(subCommandLine, subParseResult);
|
||||
}
|
||||
default:
|
||||
{
|
||||
commandLine.getErr().println("Unknown command: " + subCommandName);
|
||||
commandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
commandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Handle a command up to the point where 'process' was given
|
||||
*******************************************************************************/
|
||||
private int runProcessCommand(CommandLine commandLine, ParseResult subParseResult)
|
||||
{
|
||||
if(!subParseResult.hasSubcommand())
|
||||
{
|
||||
////////////////////////////////////////////////////////////////
|
||||
// process name must be a sub-command, so, error if not given //
|
||||
////////////////////////////////////////////////////////////////
|
||||
commandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
else
|
||||
{
|
||||
///////////////////////////////////////////
|
||||
// move on to running the actual process //
|
||||
///////////////////////////////////////////
|
||||
String subCommandName = subParseResult.subcommand().commandSpec().name();
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get(subCommandName);
|
||||
return runActualProcess(subCommandLine, subParseResult.subcommand());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** actually run a process (the process name should be at the start of the sub-command line)
|
||||
*******************************************************************************/
|
||||
private int runActualProcess(CommandLine subCommandLine, ParseResult processParseResult)
|
||||
{
|
||||
String processName = processParseResult.commandSpec().name();
|
||||
QProcessMetaData process = qInstance.getProcess(processName);
|
||||
RunProcessInput request = new RunProcessInput(qInstance);
|
||||
|
||||
request.setSession(session);
|
||||
request.setProcessName(processName);
|
||||
request.setCallback(new PicoCliProcessCallback(subCommandLine));
|
||||
|
||||
for(OptionSpec matchedOption : processParseResult.matchedOptions())
|
||||
{
|
||||
if(matchedOption.longestName().startsWith("--field-"))
|
||||
{
|
||||
String fieldName = matchedOption.longestName().substring(8);
|
||||
request.addValue(fieldName, matchedOption.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
RunProcessOutput result = new RunProcessAction().execute(request);
|
||||
subCommandLine.getOut().println("Process Results: "); // todo better!!
|
||||
for(QFieldMetaData outputField : process.getOutputFields())
|
||||
{
|
||||
subCommandLine.getOut().format(" %s: %s\n", outputField.getLabel(), result.getValues().get(outputField.getName()));
|
||||
}
|
||||
|
||||
if(result.getException().isPresent())
|
||||
{
|
||||
// todo - user-facing, similar to javalin
|
||||
subCommandLine.getOut().println("Process Error message: " + result.getException().get().getMessage());
|
||||
}
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
e.printStackTrace();
|
||||
subCommandLine.getOut().println("Caught Exception running process. See stack trace above for details.");
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableMetaData(CommandLine commandLine, String tableName, ParseResult subParseResult) throws QException
|
||||
{
|
||||
TableMetaDataInput tableMetaDataInput = new TableMetaDataInput(qInstance);
|
||||
tableMetaDataInput.setSession(session);
|
||||
tableMetaDataInput.setTableName(tableName);
|
||||
TableMetaDataAction tableMetaDataAction = new TableMetaDataAction();
|
||||
TableMetaDataOutput tableMetaDataOutput = tableMetaDataAction.execute(tableMetaDataInput);
|
||||
commandLine.getOut().println(JsonUtils.toPrettyJson(tableMetaDataOutput));
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableCount(CommandLine commandLine, String tableName, ParseResult subParseResult) throws QException
|
||||
{
|
||||
CountInput countInput = new CountInput(qInstance);
|
||||
countInput.setSession(session);
|
||||
countInput.setTableName(tableName);
|
||||
countInput.setFilter(generateQueryFilter(subParseResult));
|
||||
|
||||
CountAction countAction = new CountAction();
|
||||
CountOutput countOutput = countAction.execute(countInput);
|
||||
commandLine.getOut().println(JsonUtils.toPrettyJson(countOutput));
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableGet(CommandLine commandLine, String tableName, ParseResult subParseResult, CommandLine subCommandLine) throws QException
|
||||
{
|
||||
QueryInput queryInput = new QueryInput(qInstance);
|
||||
queryInput.setSession(session);
|
||||
queryInput.setTableName(tableName);
|
||||
queryInput.setSkip(subParseResult.matchedOptionValue("skip", null));
|
||||
String primaryKeyValue = subParseResult.matchedPositionalValue(0, null);
|
||||
|
||||
if(primaryKeyValue == null)
|
||||
{
|
||||
subCommandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
|
||||
QTableMetaData table = queryInput.getTable();
|
||||
QQueryFilter filter = new QQueryFilter()
|
||||
.withCriteria(new QFilterCriteria()
|
||||
.withFieldName(table.getPrimaryKeyField())
|
||||
.withOperator(QCriteriaOperator.EQUALS)
|
||||
.withValues(List.of(primaryKeyValue)));
|
||||
queryInput.setFilter(filter);
|
||||
|
||||
QueryAction queryAction = new QueryAction();
|
||||
QueryOutput queryOutput = queryAction.execute(queryInput);
|
||||
List<QRecord> records = queryOutput.getRecords();
|
||||
if(records.isEmpty())
|
||||
{
|
||||
commandLine.getOut().println("No " + table.getLabel() + " found for " + table.getField(table.getPrimaryKeyField()).getLabel() + ": " + primaryKeyValue);
|
||||
return commandLine.getCommandSpec().exitCodeOnInvalidInput();
|
||||
}
|
||||
else
|
||||
{
|
||||
commandLine.getOut().println(JsonUtils.toPrettyJson(records.get(0)));
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableQuery(CommandLine commandLine, String tableName, ParseResult subParseResult) throws QException
|
||||
{
|
||||
QueryInput queryInput = new QueryInput(qInstance);
|
||||
queryInput.setSession(session);
|
||||
queryInput.setTableName(tableName);
|
||||
queryInput.setSkip(subParseResult.matchedOptionValue("skip", null));
|
||||
queryInput.setLimit(subParseResult.matchedOptionValue("limit", null));
|
||||
queryInput.setFilter(generateQueryFilter(subParseResult));
|
||||
|
||||
QueryAction queryAction = new QueryAction();
|
||||
QueryOutput queryOutput = queryAction.execute(queryInput);
|
||||
commandLine.getOut().println(JsonUtils.toPrettyJson(queryOutput));
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableExport(CommandLine commandLine, String tableName, ParseResult subParseResult) throws QException
|
||||
{
|
||||
String filename = subParseResult.matchedOptionValue("--filename", "");
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////
|
||||
// if a format query param wasn't given, then try to get file extension from file name //
|
||||
/////////////////////////////////////////////////////////////////////////////////////////
|
||||
ReportFormat reportFormat;
|
||||
if(filename.contains("."))
|
||||
{
|
||||
reportFormat = ReportFormat.fromString(filename.substring(filename.lastIndexOf(".") + 1));
|
||||
}
|
||||
else
|
||||
{
|
||||
throw (new QUserFacingException("File name did not contain an extension, so report format could not be inferred."));
|
||||
}
|
||||
|
||||
OutputStream outputStream;
|
||||
try
|
||||
{
|
||||
outputStream = new FileOutputStream(filename);
|
||||
}
|
||||
catch(Exception e)
|
||||
{
|
||||
throw (new QException("Error opening report file: " + e.getMessage(), e));
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
/////////////////////////////////////////////
|
||||
// set up the report action's input object //
|
||||
/////////////////////////////////////////////
|
||||
ReportInput reportInput = new ReportInput(qInstance);
|
||||
reportInput.setSession(session);
|
||||
reportInput.setTableName(tableName);
|
||||
reportInput.setReportFormat(reportFormat);
|
||||
reportInput.setFilename(filename);
|
||||
reportInput.setReportOutputStream(outputStream);
|
||||
reportInput.setLimit(subParseResult.matchedOptionValue("limit", null));
|
||||
|
||||
reportInput.setQueryFilter(generateQueryFilter(subParseResult));
|
||||
|
||||
String fieldNames = subParseResult.matchedOptionValue("--fieldNames", "");
|
||||
if(StringUtils.hasContent(fieldNames))
|
||||
{
|
||||
reportInput.setFieldNames(Arrays.asList(fieldNames.split(",")));
|
||||
}
|
||||
|
||||
ReportOutput reportOutput = new ReportAction().execute(reportInput);
|
||||
|
||||
commandLine.getOut().println("Wrote " + reportOutput.getRecordCount() + " records to file " + filename);
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
finally
|
||||
{
|
||||
try
|
||||
{
|
||||
outputStream.close();
|
||||
}
|
||||
catch(IOException e)
|
||||
{
|
||||
throw (new QException("Error closing report file", e));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private QQueryFilter generateQueryFilter(ParseResult subParseResult)
|
||||
{
|
||||
QQueryFilter filter = new QQueryFilter();
|
||||
|
||||
String[] criteria = subParseResult.matchedOptionValue("criteria", new String[] {});
|
||||
for(String criterion : criteria)
|
||||
{
|
||||
// todo - parse!
|
||||
String[] parts = criterion.split(" ");
|
||||
QFilterCriteria qQueryCriteria = new QFilterCriteria();
|
||||
qQueryCriteria.setFieldName(parts[0]);
|
||||
qQueryCriteria.setOperator(QCriteriaOperator.valueOf(parts[1]));
|
||||
qQueryCriteria.setValues(List.of(parts[2]));
|
||||
filter.addCriteria(qQueryCriteria);
|
||||
}
|
||||
|
||||
return filter;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableInsert(CommandLine commandLine, String tableName, ParseResult subParseResult) throws QException
|
||||
{
|
||||
InsertInput insertInput = new InsertInput(qInstance);
|
||||
insertInput.setSession(session);
|
||||
insertInput.setTableName(tableName);
|
||||
QTableMetaData table = qInstance.getTable(tableName);
|
||||
|
||||
AbstractQFieldMapping<?> mapping = null;
|
||||
|
||||
if(subParseResult.hasMatchedOption("--mapping"))
|
||||
{
|
||||
String json = subParseResult.matchedOptionValue("--mapping", "");
|
||||
mapping = new JsonToQFieldMappingAdapter().buildMappingFromJson(json);
|
||||
}
|
||||
else
|
||||
{
|
||||
mapping = new QKeyBasedFieldMapping();
|
||||
for(Map.Entry<String, QFieldMetaData> entry : table.getFields().entrySet())
|
||||
{
|
||||
((QKeyBasedFieldMapping) mapping).addMapping(entry.getKey(), entry.getValue().getLabel());
|
||||
}
|
||||
}
|
||||
|
||||
/////////////////////////////////////////////
|
||||
// get the records that the user specified //
|
||||
/////////////////////////////////////////////
|
||||
List<QRecord> recordList;
|
||||
if(subParseResult.hasMatchedOption("--jsonBody"))
|
||||
{
|
||||
String json = subParseResult.matchedOptionValue("--jsonBody", "");
|
||||
recordList = new JsonToQRecordAdapter().buildRecordsFromJson(json, table, mapping);
|
||||
}
|
||||
else if(subParseResult.hasMatchedOption("--jsonFile"))
|
||||
{
|
||||
try
|
||||
{
|
||||
String path = subParseResult.matchedOptionValue("--jsonFile", "");
|
||||
String json = FileUtils.readFileToString(new File(path));
|
||||
recordList = new JsonToQRecordAdapter().buildRecordsFromJson(json, table, mapping);
|
||||
}
|
||||
catch(IOException e)
|
||||
{
|
||||
throw (new QException("Error building records from file:" + e.getMessage(), e));
|
||||
}
|
||||
}
|
||||
else if(subParseResult.hasMatchedOption("--csvFile"))
|
||||
{
|
||||
try
|
||||
{
|
||||
String path = subParseResult.matchedOptionValue("--csvFile", "");
|
||||
String csv = FileUtils.readFileToString(new File(path));
|
||||
recordList = new CsvToQRecordAdapter().buildRecordsFromCsv(csv, table, mapping);
|
||||
}
|
||||
catch(IOException e)
|
||||
{
|
||||
throw (new QException("Error building records from file:" + e.getMessage(), e));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
QRecord record = new QRecord();
|
||||
recordList = new ArrayList<>();
|
||||
recordList.add(record);
|
||||
|
||||
boolean anyFields = false;
|
||||
for(OptionSpec matchedOption : subParseResult.matchedOptions())
|
||||
{
|
||||
if(matchedOption.longestName().startsWith("--field-"))
|
||||
{
|
||||
anyFields = true;
|
||||
String fieldName = matchedOption.longestName().substring(8);
|
||||
record.setValue(fieldName, matchedOption.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
if(!anyFields)
|
||||
{
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get("insert");
|
||||
subCommandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
}
|
||||
|
||||
insertInput.setRecords(recordList);
|
||||
|
||||
InsertAction insertAction = new InsertAction();
|
||||
InsertOutput insertOutput = insertAction.execute(insertInput);
|
||||
commandLine.getOut().println(JsonUtils.toPrettyJson(insertOutput));
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableUpdate(CommandLine commandLine, String tableName, ParseResult subParseResult) throws QException
|
||||
{
|
||||
UpdateInput updateInput = new UpdateInput(qInstance);
|
||||
updateInput.setSession(session);
|
||||
updateInput.setTableName(tableName);
|
||||
QTableMetaData table = qInstance.getTable(tableName);
|
||||
|
||||
List<QRecord> recordsToUpdate = new ArrayList<>();
|
||||
boolean anyFields = false;
|
||||
|
||||
String primaryKeyOption = subParseResult.matchedOptionValue("--primaryKey", "");
|
||||
String[] criteria = subParseResult.matchedOptionValue("criteria", new String[] {});
|
||||
|
||||
if(StringUtils.hasContent(primaryKeyOption))
|
||||
{
|
||||
//////////////////////////////////////////////////////////////////////////////////////
|
||||
// if the primaryKey option was given, split it up and seed the recordToUpdate list //
|
||||
//////////////////////////////////////////////////////////////////////////////////////
|
||||
Serializable[] primaryKeyValues = primaryKeyOption.split(",");
|
||||
for(Serializable primaryKeyValue : primaryKeyValues)
|
||||
{
|
||||
recordsToUpdate.add(new QRecord().withValue(table.getPrimaryKeyField(), primaryKeyValue));
|
||||
}
|
||||
}
|
||||
else if(criteria.length > 0)
|
||||
{
|
||||
//////////////////////////////////////////////////////////////////////////////////////
|
||||
// else if criteria were given, execute the query for the lsit of records to update //
|
||||
//////////////////////////////////////////////////////////////////////////////////////
|
||||
for(QRecord qRecord : executeQuery(tableName, subParseResult))
|
||||
{
|
||||
recordsToUpdate.add(new QRecord().withValue(table.getPrimaryKeyField(), qRecord.getValue(table.getPrimaryKeyField())));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
commandLine.getErr().println("Error: Either primaryKey or criteria must be specified.");
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get("update");
|
||||
subCommandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////
|
||||
// make sure at least one --field- arg was given //
|
||||
///////////////////////////////////////////////////
|
||||
for(OptionSpec matchedOption : subParseResult.matchedOptions())
|
||||
{
|
||||
if(matchedOption.longestName().startsWith("--field-"))
|
||||
{
|
||||
anyFields = true;
|
||||
}
|
||||
}
|
||||
|
||||
if(!anyFields)
|
||||
{
|
||||
commandLine.getErr().println("Error: At least one field to update must be specified.");
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get("update");
|
||||
subCommandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
|
||||
if(recordsToUpdate.isEmpty())
|
||||
{
|
||||
commandLine.getErr().println("No rows to update were found.");
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get("update");
|
||||
subCommandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
|
||||
for(QRecord record : recordsToUpdate)
|
||||
{
|
||||
for(OptionSpec matchedOption : subParseResult.matchedOptions())
|
||||
{
|
||||
if(matchedOption.longestName().startsWith("--field-"))
|
||||
{
|
||||
String fieldName = matchedOption.longestName().substring(8);
|
||||
record.setValue(fieldName, matchedOption.getValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
updateInput.setRecords(recordsToUpdate);
|
||||
|
||||
UpdateAction updateAction = new UpdateAction();
|
||||
UpdateOutput updateResult = updateAction.execute(updateInput);
|
||||
commandLine.getOut().println(JsonUtils.toPrettyJson(updateResult));
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTableDelete(CommandLine commandLine, String tableName, ParseResult subParseResult) throws QException
|
||||
{
|
||||
DeleteInput deleteInput = new DeleteInput(qInstance);
|
||||
deleteInput.setSession(session);
|
||||
deleteInput.setTableName(tableName);
|
||||
|
||||
/////////////////////////////////////////////
|
||||
// get the pKeys that the user specified //
|
||||
/////////////////////////////////////////////
|
||||
String primaryKeyOption = subParseResult.matchedOptionValue("--primaryKey", "");
|
||||
String[] criteria = subParseResult.matchedOptionValue("criteria", new String[] {});
|
||||
|
||||
if(StringUtils.hasContent(primaryKeyOption))
|
||||
{
|
||||
deleteInput.setPrimaryKeys(Arrays.asList(primaryKeyOption.split(",")));
|
||||
}
|
||||
else if(criteria.length > 0)
|
||||
{
|
||||
deleteInput.setQueryFilter(generateQueryFilter(subParseResult));
|
||||
}
|
||||
else
|
||||
{
|
||||
commandLine.getErr().println("Error: Either primaryKey or criteria must be specified.");
|
||||
CommandLine subCommandLine = commandLine.getSubcommands().get("delete");
|
||||
subCommandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
|
||||
DeleteAction deleteAction = new DeleteAction();
|
||||
DeleteOutput deleteResult = deleteAction.execute(deleteInput);
|
||||
commandLine.getOut().println(JsonUtils.toPrettyJson(deleteResult));
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private int runTopLevelCommand(CommandLine commandLine, ParseResult parseResult) throws QException
|
||||
{
|
||||
if(parseResult.hasMatchedOption("--meta-data"))
|
||||
{
|
||||
MetaDataInput metaDataInput = new MetaDataInput(qInstance);
|
||||
metaDataInput.setSession(session);
|
||||
MetaDataAction metaDataAction = new MetaDataAction();
|
||||
MetaDataOutput metaDataOutput = metaDataAction.execute(metaDataInput);
|
||||
commandLine.getOut().println(JsonUtils.toPrettyJson(metaDataOutput));
|
||||
return commandLine.getCommandSpec().exitCodeOnSuccess();
|
||||
}
|
||||
|
||||
commandLine.usage(commandLine.getOut());
|
||||
return commandLine.getCommandSpec().exitCodeOnUsageHelp();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private List<QRecord> executeQuery(String tableName, ParseResult subParseResult) throws QException
|
||||
{
|
||||
QueryInput queryInput = new QueryInput(qInstance);
|
||||
queryInput.setSession(session);
|
||||
queryInput.setTableName(tableName);
|
||||
queryInput.setFilter(generateQueryFilter(subParseResult));
|
||||
|
||||
QueryAction queryAction = new QueryAction();
|
||||
QueryOutput queryOutput = queryAction.execute(queryInput);
|
||||
return (queryOutput.getRecords());
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,18 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<Configuration>
|
||||
<Properties>
|
||||
<Property name="LOG_PATTERN">%date{ISO8601} | %relative | %level | %threadName{1} | %logger{1}.%method | %message%n</Property>
|
||||
</Properties>
|
||||
<Appenders>
|
||||
<File name="LogFile" fileName="log/qqq-picocli.log">
|
||||
<PatternLayout pattern="${LOG_PATTERN}"/>
|
||||
</File>
|
||||
</Appenders>
|
||||
<Loggers>
|
||||
<Logger name="org.apache.log4j.xml" additivity="false">
|
||||
</Logger>
|
||||
<Root level="all">
|
||||
<AppenderRef ref="LogFile"/>
|
||||
</Root>
|
||||
</Loggers>
|
||||
</Configuration>
|
||||
@ -0,0 +1,966 @@
|
||||
/*
|
||||
* QQQ - Low-code Application Framework for Engineers.
|
||||
* Copyright (C) 2021-2022. Kingsrook, LLC
|
||||
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
|
||||
* contact@kingsrook.com
|
||||
* https://github.com/Kingsrook/
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package com.kingsrook.qqq.frontend.picocli;
|
||||
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.PrintStream;
|
||||
import java.nio.charset.Charset;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
|
||||
import com.kingsrook.qqq.backend.core.utils.JsonUtils;
|
||||
import com.kingsrook.qqq.backend.core.utils.StringUtils;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.json.JSONArray;
|
||||
import org.json.JSONObject;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
import static org.junit.jupiter.api.Assertions.fail;
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Unit test for the QPicoCliImplementation.
|
||||
**
|
||||
*******************************************************************************/
|
||||
class QPicoCliImplementationTest
|
||||
{
|
||||
private static final boolean VERBOSE = true;
|
||||
private static final String CLI_NAME = "cli-unit-test";
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Fully rebuild the test-database before each test runs, for completely known state.
|
||||
**
|
||||
*******************************************************************************/
|
||||
@BeforeEach
|
||||
public void beforeEach() throws Exception
|
||||
{
|
||||
TestUtils.primeTestDatabase();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test that w/ no arguments you just get usage.
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_noArgs()
|
||||
{
|
||||
TestOutput testOutput = testCli();
|
||||
assertTestOutputContains(testOutput, "Usage: " + CLI_NAME);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test that --help gives you usage.
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_help()
|
||||
{
|
||||
TestOutput testOutput = testCli("--help");
|
||||
assertTestOutputContains(testOutput, "Usage: " + CLI_NAME);
|
||||
assertTestOutputContains(testOutput, "Commands:.*person");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test the --verion argument
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_version()
|
||||
{
|
||||
TestOutput testOutput = testCli("--version");
|
||||
assertTestOutputContains(testOutput, CLI_NAME + " v1.0");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Test that an unrecognized opttion gives an error
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_badOption()
|
||||
{
|
||||
String badOption = "--asdf";
|
||||
TestOutput testOutput = testCli(badOption);
|
||||
assertTestErrorContains(testOutput, "Unknown option: '" + badOption + "'");
|
||||
assertTestErrorContains(testOutput, "Usage: " + CLI_NAME);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test the top-level --meta-data option
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_metaData()
|
||||
{
|
||||
TestOutput testOutput = testCli("--meta-data");
|
||||
JSONObject metaData = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(metaData);
|
||||
assertEquals(2, metaData.keySet().size(), "Number of top-level keys");
|
||||
|
||||
assertTrue(metaData.has("tables"));
|
||||
JSONObject tables = metaData.getJSONObject("tables");
|
||||
JSONObject personTable = tables.getJSONObject("person");
|
||||
assertEquals("person", personTable.getString("name"));
|
||||
assertEquals("Person", personTable.getString("label"));
|
||||
|
||||
assertTrue(metaData.has("processes"));
|
||||
JSONObject processes = metaData.getJSONObject("processes");
|
||||
JSONObject greetProcess = processes.getJSONObject("greet");
|
||||
assertEquals("greet", greetProcess.getString("name"));
|
||||
assertEquals("Greet", greetProcess.getString("label"));
|
||||
assertEquals("person", greetProcess.getString("tableName"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test giving a table-name, gives usage for that table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_table()
|
||||
{
|
||||
TestOutput testOutput = testCli("person");
|
||||
assertTestOutputContains(testOutput, "Usage: " + CLI_NAME + " person \\[COMMAND\\]");
|
||||
assertTestOutputContains(testOutput, "Commands:.*query.*process");
|
||||
|
||||
///////////////////////////////////////////////////////
|
||||
// make sure that if there are no processes for the //
|
||||
// table, that the processes sub-command isn't given //
|
||||
///////////////////////////////////////////////////////
|
||||
QInstance qInstanceWithoutProcesses = TestUtils.defineInstance();
|
||||
qInstanceWithoutProcesses.setProcesses(new HashMap<>());
|
||||
testOutput = testCli(qInstanceWithoutProcesses, "person");
|
||||
assertTestOutputDoesNotContain(testOutput, "process");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test unknown command under table, prints error and usage.
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableUnknownCommand()
|
||||
{
|
||||
String badCommand = "qwuijibo";
|
||||
TestOutput testOutput = testCli("person", badCommand);
|
||||
assertTestErrorContains(testOutput, "Unmatched argument at index 1: '" + badCommand + "'");
|
||||
assertTestErrorContains(testOutput, "Usage: " + CLI_NAME + " person \\[COMMAND\\]");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test requesting table meta-data
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableMetaData()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "meta-data");
|
||||
JSONObject metaData = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(metaData);
|
||||
assertEquals(1, metaData.keySet().size(), "Number of top-level keys");
|
||||
JSONObject table = metaData.getJSONObject("table");
|
||||
assertEquals("person", table.getString("name"));
|
||||
assertEquals("Person", table.getString("label"));
|
||||
assertEquals("id", table.getString("primaryKeyField"));
|
||||
JSONObject fields = table.getJSONObject("fields");
|
||||
JSONObject field0 = fields.getJSONObject("id");
|
||||
assertEquals("id", field0.getString("name"));
|
||||
assertEquals("INTEGER", field0.getString("type"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a count on a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableCount()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "count", "--criteria", "id NOT_EQUALS 3");
|
||||
JSONObject countResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(countResult);
|
||||
int count = countResult.getInt("count");
|
||||
assertEquals(4, count);
|
||||
|
||||
testOutput = testCli("person", "count", "--criteria", "id EQUALS 3");
|
||||
countResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(countResult);
|
||||
count = countResult.getInt("count");
|
||||
assertEquals(1, count);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a query on a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableQuery()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "query", "--skip=1", "--limit=2", "--criteria", "id NOT_EQUALS 3");
|
||||
JSONObject queryResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(queryResult);
|
||||
JSONArray records = queryResult.getJSONArray("records");
|
||||
assertEquals(2, records.length());
|
||||
// query for id != 3, and skipping 1, expect to get back rows 2 & 4
|
||||
assertEquals(2, records.getJSONObject(0).getJSONObject("values").getInt("id"));
|
||||
assertEquals(4, records.getJSONObject(1).getJSONObject("values").getInt("id"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a "get single record" action (singleton query) on a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableGetNoIdGiven()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "get");
|
||||
assertTestOutputContains(testOutput, "Usage: " + CLI_NAME + " person get PARAM");
|
||||
assertTestOutputContains(testOutput, "Primary key value from the table");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a "get single record" action (singleton query) on a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableGet()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "get", "1");
|
||||
JSONObject getResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(getResult);
|
||||
assertEquals(1, getResult.getJSONObject("values").getInt("id"));
|
||||
assertEquals("Darin", getResult.getJSONObject("values").getString("firstName"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a "get single record" action (singleton query) on a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableGetMissingId()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "get", "1976");
|
||||
assertTestOutputContains(testOutput, "No Person found for Id: 1976");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an insert w/o specifying any fields, prints usage
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableInsertNoFieldsPrintsUsage()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "insert");
|
||||
assertTestOutputContains(testOutput, "Usage: " + CLI_NAME + " person insert");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an insert w/ fields as arguments
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableInsertFieldArguments()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "insert",
|
||||
"--field-firstName=Lucy",
|
||||
"--field-lastName=Lu",
|
||||
"--field-email=lucy@kingsrook.com");
|
||||
JSONObject insertResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(insertResult);
|
||||
assertEquals(1, insertResult.getJSONArray("records").length());
|
||||
assertEquals(6, insertResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getInt("id"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an insert w/ a mapping and json as an argument
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableInsertJsonObjectArgumentWithMapping()
|
||||
{
|
||||
String mapping = """
|
||||
--mapping={"firstName":"first","lastName":"ln","email":"email"}
|
||||
""";
|
||||
|
||||
String jsonBody = """
|
||||
--jsonBody={"first":"Chester","ln":"Cheese","email":"chester@kingsrook.com"}
|
||||
""";
|
||||
|
||||
TestOutput testOutput = testCli("person", "insert", mapping, jsonBody);
|
||||
JSONObject insertResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(insertResult);
|
||||
assertEquals(1, insertResult.getJSONArray("records").length());
|
||||
assertEquals(6, insertResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getInt("id"));
|
||||
assertEquals("Chester", insertResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getString("firstName"));
|
||||
assertEquals("Cheese", insertResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getString("lastName"));
|
||||
assertEquals("chester@kingsrook.com", insertResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getString("email"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an insert w/ a mapping and json as a multi-record file
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableInsertJsonArrayFileWithMapping() throws IOException
|
||||
{
|
||||
String mapping = """
|
||||
--mapping={"firstName":"first","lastName":"ln","email":"email"}
|
||||
""";
|
||||
|
||||
String jsonContents = """
|
||||
[
|
||||
{"first":"Charlie","ln":"Bear","email":"charlie-bear@kingsrook.com"},
|
||||
{"first":"Coco","ln":"Bean","email":"coco-bean@kingsrook.com"}
|
||||
]
|
||||
""";
|
||||
|
||||
File file = new File("/tmp/" + UUID.randomUUID() + ".json");
|
||||
file.deleteOnExit();
|
||||
FileUtils.writeStringToFile(file, jsonContents);
|
||||
|
||||
TestOutput testOutput = testCli("person", "insert", mapping, "--jsonFile=" + file.getAbsolutePath());
|
||||
JSONObject insertResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(insertResult);
|
||||
JSONArray records = insertResult.getJSONArray("records");
|
||||
assertEquals(2, records.length());
|
||||
assertEquals(6, insertResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getInt("id"));
|
||||
assertEquals(7, insertResult.getJSONArray("records").getJSONObject(1).getJSONObject("values").getInt("id"));
|
||||
assertEquals("Charlie", records.getJSONObject(0).getJSONObject("values").getString("firstName"));
|
||||
assertEquals("Bear", records.getJSONObject(0).getJSONObject("values").getString("lastName"));
|
||||
assertEquals("charlie-bear@kingsrook.com", records.getJSONObject(0).getJSONObject("values").getString("email"));
|
||||
assertEquals("Coco", records.getJSONObject(1).getJSONObject("values").getString("firstName"));
|
||||
assertEquals("Bean", records.getJSONObject(1).getJSONObject("values").getString("lastName"));
|
||||
assertEquals("coco-bean@kingsrook.com", records.getJSONObject(1).getJSONObject("values").getString("email"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an insert w/ an index-based mapping and csv file
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableInsertCsvFileWithIndexMapping() throws IOException
|
||||
{
|
||||
String mapping = """
|
||||
--mapping={"firstName":1,"lastName":3,"email":5}
|
||||
""";
|
||||
|
||||
String csvContents = """
|
||||
"Louis","P","Willikers",1024,"louis@kingsrook.com",
|
||||
"Nestle","G","Crunch",1701,"nestle@kingsrook.com",
|
||||
|
||||
""";
|
||||
|
||||
File file = new File("/tmp/" + UUID.randomUUID() + ".csv");
|
||||
file.deleteOnExit();
|
||||
FileUtils.writeStringToFile(file, csvContents);
|
||||
|
||||
TestOutput testOutput = testCli("person", "insert", mapping, "--csvFile=" + file.getAbsolutePath());
|
||||
JSONObject insertResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(insertResult);
|
||||
JSONArray records = insertResult.getJSONArray("records");
|
||||
assertEquals(2, records.length());
|
||||
assertEquals(6, insertResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getInt("id"));
|
||||
assertEquals(7, insertResult.getJSONArray("records").getJSONObject(1).getJSONObject("values").getInt("id"));
|
||||
assertEquals("Louis", records.getJSONObject(0).getJSONObject("values").getString("firstName"));
|
||||
assertEquals("Willikers", records.getJSONObject(0).getJSONObject("values").getString("lastName"));
|
||||
assertEquals("Nestle", records.getJSONObject(1).getJSONObject("values").getString("firstName"));
|
||||
assertEquals("Crunch", records.getJSONObject(1).getJSONObject("values").getString("lastName"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an update w/o specifying any fields, prints usage
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableUpdateNoFieldsPrintsUsage()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "update");
|
||||
assertTestOutputContains(testOutput, "Usage: " + CLI_NAME + " person update");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an update w/o specifying any pkeys or criteria, prints usage
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableUpdateNoRecordsPrintsUsage()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "update", "--field-firstName=Lucy");
|
||||
assertTestOutputContains(testOutput, "Usage: " + CLI_NAME + " person update");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an update w/ fields as arguments and one primary key
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableUpdateFieldArgumentsOnePrimaryKey() throws Exception
|
||||
{
|
||||
assertRowValueById("person", "first_name", "Garret", 5);
|
||||
TestOutput testOutput = testCli("person", "update",
|
||||
"--primaryKey=5",
|
||||
"--field-firstName=Lucy",
|
||||
"--field-lastName=Lu");
|
||||
JSONObject updateResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(updateResult);
|
||||
assertEquals(1, updateResult.getJSONArray("records").length());
|
||||
assertEquals(5, updateResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getInt("id"));
|
||||
assertRowValueById("person", "first_name", "Lucy", 5);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an update w/ fields as arguments and multiple primary keys
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableUpdateFieldArgumentsManyPrimaryKeys() throws Exception
|
||||
{
|
||||
assertRowValueById("person", "first_name", "Tyler", 4);
|
||||
assertRowValueById("person", "first_name", "Garret", 5);
|
||||
TestOutput testOutput = testCli("person", "update",
|
||||
"--primaryKey=4,5",
|
||||
"--field-birthDate=1980-05-31",
|
||||
"--field-firstName=Lucy",
|
||||
"--field-lastName=Lu");
|
||||
JSONObject updateResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(updateResult);
|
||||
assertEquals(2, updateResult.getJSONArray("records").length());
|
||||
assertEquals(4, updateResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getInt("id"));
|
||||
assertEquals(5, updateResult.getJSONArray("records").getJSONObject(1).getJSONObject("values").getInt("id"));
|
||||
assertRowValueById("person", "first_name", "Lucy", 4);
|
||||
assertRowValueById("person", "first_name", "Lucy", 5);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running an update w/ fields as arguments and a criteria
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableUpdateFieldArgumentsCriteria() throws Exception
|
||||
{
|
||||
assertRowValueById("person", "first_name", "Tyler", 4);
|
||||
assertRowValueById("person", "first_name", "Garret", 5);
|
||||
TestOutput testOutput = testCli("person", "update",
|
||||
"--criteria",
|
||||
"id GREATER_THAN_OR_EQUALS 4",
|
||||
"--field-firstName=Lucy",
|
||||
"--field-lastName=Lu");
|
||||
JSONObject updateResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(updateResult);
|
||||
assertEquals(2, updateResult.getJSONArray("records").length());
|
||||
assertEquals(4, updateResult.getJSONArray("records").getJSONObject(0).getJSONObject("values").getInt("id"));
|
||||
assertEquals(5, updateResult.getJSONArray("records").getJSONObject(1).getJSONObject("values").getInt("id"));
|
||||
assertRowValueById("person", "first_name", "Lucy", 4);
|
||||
assertRowValueById("person", "first_name", "Lucy", 5);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private void assertRowValueById(String tableName, String columnName, String value, Integer id) throws Exception
|
||||
{
|
||||
TestUtils.runTestSql("SELECT " + columnName + " FROM " + tableName + " WHERE id=" + id, (rs -> {
|
||||
if(rs.next())
|
||||
{
|
||||
assertEquals(value, rs.getString(1));
|
||||
}
|
||||
else
|
||||
{
|
||||
fail("Row not found");
|
||||
}
|
||||
}));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a delete without enough args
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableDeleteWithoutArgs() throws Exception
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "delete");
|
||||
assertTestOutputContains(testOutput, "Usage: " + CLI_NAME + " person delete");
|
||||
}
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a delete against a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableDelete() throws Exception
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "delete", "--primaryKey", "2,4");
|
||||
JSONObject deleteResult = JsonUtils.toJSONObject(testOutput.getOutput());
|
||||
assertNotNull(deleteResult);
|
||||
assertEquals(2, deleteResult.getInt("deletedRecordCount"));
|
||||
TestUtils.runTestSql("SELECT id FROM person", (rs -> {
|
||||
int rowsFound = 0;
|
||||
while(rs.next())
|
||||
{
|
||||
rowsFound++;
|
||||
assertTrue(rs.getInt(1) == 1 || rs.getInt(1) == 3 || rs.getInt(1) == 5);
|
||||
}
|
||||
assertEquals(3, rowsFound);
|
||||
}));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test requesting the list of processes for a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableProcess()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "process");
|
||||
|
||||
////////////////////////////////////////////////
|
||||
// should list the processes under this table //
|
||||
////////////////////////////////////////////////
|
||||
assertTestOutputContains(testOutput, "Commands.*greet");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test trying to run a process, but giving an invalid name.
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableProcessUnknownName()
|
||||
{
|
||||
String badProcessName = "not-a-process";
|
||||
TestOutput testOutput = testCli("person", "process", badProcessName);
|
||||
assertTestErrorContains(testOutput, "Unmatched argument at index 2: '" + badProcessName + "'");
|
||||
assertTestErrorContains(testOutput, "Usage: " + CLI_NAME + " person process \\[COMMAND\\]");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a process on a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableProcessGreetUsingCallbackForFields()
|
||||
{
|
||||
setStandardInputLines("Hi", "How are you?");
|
||||
TestOutput testOutput = testCli("person", "process", "greet");
|
||||
assertTestOutputContains(testOutput, "Please supply a value for the field.*Greeting Prefix");
|
||||
assertTestOutputContains(testOutput, "Hi X How are you?");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportNoArgsExcel()
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID() + ".xlsx";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename);
|
||||
assertTestOutputContains(testOutput, "Wrote 5 records to file " + filename);
|
||||
|
||||
File file = new File(filename);
|
||||
assertTrue(file.exists());
|
||||
|
||||
// todo - some day when we learn to read Excel, assert that we wrote as expected.
|
||||
|
||||
deleteFile(file);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportWithLimit() throws Exception
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID() + ".csv";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename, "--limit=3");
|
||||
assertTestOutputContains(testOutput, "Wrote 3 records to file " + filename);
|
||||
|
||||
File file = new File(filename);
|
||||
@SuppressWarnings("unchecked")
|
||||
List<String> list = FileUtils.readLines(file);
|
||||
assertEquals(4, list.size());
|
||||
assertThat(list.get(0)).contains("""
|
||||
"Id","Create Date","Modify Date\"""");
|
||||
assertThat(list.get(1)).matches("""
|
||||
^"1",.*"Darin.*""");
|
||||
assertThat(list.get(3)).matches("""
|
||||
^"3",.*"Tim.*""");
|
||||
|
||||
deleteFile(file);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportWithCriteria() throws Exception
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID() + ".csv";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename, "--criteria", "id NOT_EQUALS 3");
|
||||
assertTestOutputContains(testOutput, "Wrote 4 records to file " + filename);
|
||||
|
||||
File file = new File(filename);
|
||||
@SuppressWarnings("unchecked")
|
||||
List<String> list = FileUtils.readLines(file);
|
||||
assertEquals(5, list.size());
|
||||
assertThat(list.get(0)).contains("""
|
||||
"Id","Create Date","Modify Date\"""");
|
||||
assertThat(list.get(1)).matches("^\"1\",.*");
|
||||
assertThat(list.get(2)).matches("^\"2\",.*");
|
||||
assertThat(list.get(3)).matches("^\"4\",.*");
|
||||
assertThat(list.get(4)).matches("^\"5\",.*");
|
||||
|
||||
deleteFile(file);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportWithoutFilename()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "export");
|
||||
assertTestErrorContains(testOutput, "Missing required option: '--filename=PARAM'");
|
||||
assertTestErrorContains(testOutput, "Usage: " + CLI_NAME + " person export");
|
||||
assertTestErrorContains(testOutput, "-f=PARAM");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportNoFileExtension()
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID();
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename);
|
||||
assertTestErrorContains(testOutput, "File name did not contain an extension");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportBadFileType()
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID() + ".docx";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename);
|
||||
assertTestErrorContains(testOutput, "Unsupported report format: docx.");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportBadFilePath()
|
||||
{
|
||||
String filename = "/no-such/directory/" + UUID.randomUUID() + "report.csv";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename);
|
||||
assertTestErrorContains(testOutput, "No such file or directory");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportBadFieldNams()
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID() + ".csv";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename, "--fieldNames=foo");
|
||||
assertTestErrorContains(testOutput, "Field name foo was not found on the Person table");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportBadFieldNames()
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID() + ".csv";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename, "--fieldNames=foo,bar,baz");
|
||||
assertTestErrorContains(testOutput, "Fields names foo, bar, and baz were not found on the Person table");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportGoodFieldNamesXslx() throws IOException
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID() + ".xlsx";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename, "--fieldNames=id,lastName,birthDate");
|
||||
|
||||
File file = new File(filename);
|
||||
assertTrue(file.exists());
|
||||
|
||||
// todo - some day when we learn to read Excel, assert that we wrote as expected (with 3 columns)
|
||||
|
||||
deleteFile(file);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test exporting a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableExportGoodFieldNamesCSV() throws IOException
|
||||
{
|
||||
String filename = "/tmp/" + UUID.randomUUID() + ".csv";
|
||||
TestOutput testOutput = testCli("person", "export", "--filename=" + filename, "--fieldNames=id,lastName,birthDate");
|
||||
|
||||
File file = new File(filename);
|
||||
@SuppressWarnings("unchecked")
|
||||
List<String> list = FileUtils.readLines(file);
|
||||
assertEquals(6, list.size());
|
||||
assertThat(list.get(0)).isEqualTo("""
|
||||
"Id","Last Name","Birth Date\"""");
|
||||
assertThat(list.get(1)).isEqualTo("""
|
||||
"1","Kelkhoff","1980-05-31\"""");
|
||||
|
||||
deleteFile(file);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** test running a process on a table
|
||||
**
|
||||
*******************************************************************************/
|
||||
@Test
|
||||
public void test_tableProcessGreetUsingOptionsForFields()
|
||||
{
|
||||
TestOutput testOutput = testCli("person", "process", "greet", "--field-greetingPrefix=Hello", "--field-greetingSuffix=World");
|
||||
assertTestOutputDoesNotContain(testOutput, "Please supply a value for the field");
|
||||
assertTestOutputContains(testOutput, "Hello X World");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private void assertTestOutputContains(TestOutput testOutput, String expectedRegexSubstring)
|
||||
{
|
||||
if(!testOutput.getOutput().matches("(?s).*" + expectedRegexSubstring + ".*"))
|
||||
{
|
||||
fail("Expected output to contain this regex pattern:\n" + expectedRegexSubstring
|
||||
+ "\nBut it did not. The full output was:\n" + testOutput.getOutput());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private void assertTestOutputDoesNotContain(TestOutput testOutput, String expectedRegexSubstring)
|
||||
{
|
||||
if(testOutput.getOutput().matches("(?s).*" + expectedRegexSubstring + ".*"))
|
||||
{
|
||||
fail("Expected output to not contain this regex pattern:\n" + expectedRegexSubstring
|
||||
+ "\nBut it did. The full output was:\n" + testOutput.getOutput());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private void assertTestErrorContains(TestOutput testOutput, String expectedRegexSubstring)
|
||||
{
|
||||
if(!testOutput.getError().matches("(?s).*" + expectedRegexSubstring + ".*"))
|
||||
{
|
||||
fail("Expected error-output to contain this regex pattern:\n" + expectedRegexSubstring
|
||||
+ "\nBut it did not. The full error-output was:\n" + testOutput.getOutput());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** delete a file, asserting that we did so.
|
||||
*******************************************************************************/
|
||||
private void deleteFile(File file)
|
||||
{
|
||||
assertTrue(file.delete());
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private TestOutput testCli(String... args)
|
||||
{
|
||||
QInstance qInstance = TestUtils.defineInstance();
|
||||
return testCli(qInstance, args);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private TestOutput testCli(QInstance qInstance, String... args)
|
||||
{
|
||||
QPicoCliImplementation qPicoCliImplementation = new QPicoCliImplementation(qInstance);
|
||||
|
||||
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
|
||||
ByteArrayOutputStream errorStream = new ByteArrayOutputStream();
|
||||
|
||||
if(VERBOSE)
|
||||
{
|
||||
System.out.println("> " + CLI_NAME + (args == null ? "" : " " + StringUtils.join(" ", Arrays.stream(args).toList())));
|
||||
}
|
||||
|
||||
qPicoCliImplementation.runCli(CLI_NAME, args, new PrintStream(outputStream, true), new PrintStream(errorStream, true));
|
||||
|
||||
String output = outputStream.toString(StandardCharsets.UTF_8);
|
||||
String error = errorStream.toString(StandardCharsets.UTF_8);
|
||||
|
||||
if(VERBOSE)
|
||||
{
|
||||
System.out.println(output);
|
||||
System.err.println(error);
|
||||
}
|
||||
|
||||
TestOutput testOutput = new TestOutput(output, error);
|
||||
return (testOutput);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
private void setStandardInputLines(String... lines)
|
||||
{
|
||||
StringBuilder stringBuilder = new StringBuilder();
|
||||
for(String line : lines)
|
||||
{
|
||||
stringBuilder.append(line);
|
||||
if(!line.endsWith("\n"))
|
||||
{
|
||||
stringBuilder.append("\n");
|
||||
}
|
||||
}
|
||||
ByteArrayInputStream stdin = new ByteArrayInputStream(stringBuilder.toString().getBytes(Charset.defaultCharset()));
|
||||
System.setIn(stdin);
|
||||
}
|
||||
|
||||
}
|
||||
@ -0,0 +1,136 @@
|
||||
/*
|
||||
* QQQ - Low-code Application Framework for Engineers.
|
||||
* Copyright (C) 2021-2022. Kingsrook, LLC
|
||||
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
|
||||
* contact@kingsrook.com
|
||||
* https://github.com/Kingsrook/
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package com.kingsrook.qqq.frontend.picocli;
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
class TestOutput
|
||||
{
|
||||
private String output;
|
||||
private String[] outputLines;
|
||||
private String error;
|
||||
private String[] errorLines;
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
**
|
||||
*******************************************************************************/
|
||||
public TestOutput(String output, String error)
|
||||
{
|
||||
this.output = output;
|
||||
this.error = error;
|
||||
|
||||
this.outputLines = output.split("\n");
|
||||
this.errorLines = error.split("\n");
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Getter for output
|
||||
**
|
||||
*******************************************************************************/
|
||||
public String getOutput()
|
||||
{
|
||||
return output;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Setter for output
|
||||
**
|
||||
*******************************************************************************/
|
||||
public void setOutput(String output)
|
||||
{
|
||||
this.output = output;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Getter for outputLines
|
||||
**
|
||||
*******************************************************************************/
|
||||
public String[] getOutputLines()
|
||||
{
|
||||
return outputLines;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Setter for outputLines
|
||||
**
|
||||
*******************************************************************************/
|
||||
public void setOutputLines(String[] outputLines)
|
||||
{
|
||||
this.outputLines = outputLines;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Getter for error
|
||||
**
|
||||
*******************************************************************************/
|
||||
public String getError()
|
||||
{
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Setter for error
|
||||
**
|
||||
*******************************************************************************/
|
||||
public void setError(String error)
|
||||
{
|
||||
this.error = error;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Getter for errorLines
|
||||
**
|
||||
*******************************************************************************/
|
||||
public String[] getErrorLines()
|
||||
{
|
||||
return errorLines;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Setter for errorLines
|
||||
**
|
||||
*******************************************************************************/
|
||||
public void setErrorLines(String[] errorLines)
|
||||
{
|
||||
this.errorLines = errorLines;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,189 @@
|
||||
/*
|
||||
* QQQ - Low-code Application Framework for Engineers.
|
||||
* Copyright (C) 2021-2022. Kingsrook, LLC
|
||||
* 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
|
||||
* contact@kingsrook.com
|
||||
* https://github.com/Kingsrook/
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Affero General Public License as
|
||||
* published by the Free Software Foundation, either version 3 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Affero General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Affero General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package com.kingsrook.qqq.frontend.picocli;
|
||||
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.sql.Connection;
|
||||
import java.util.List;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.QAuthenticationType;
|
||||
import com.kingsrook.qqq.backend.core.processes.implementations.mock.MockBackendStep;
|
||||
import com.kingsrook.qqq.backend.core.modules.authentication.metadata.QAuthenticationMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeReference;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeType;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.code.QCodeUsage;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.fields.QFieldType;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.QInstance;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.tables.QTableMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.processes.QBackendStepMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.processes.QFunctionInputMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.processes.QFunctionOutputMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.processes.QProcessMetaData;
|
||||
import com.kingsrook.qqq.backend.core.model.metadata.processes.QRecordListMetaData;
|
||||
import com.kingsrook.qqq.backend.module.rdbms.jdbc.ConnectionManager;
|
||||
import com.kingsrook.qqq.backend.module.rdbms.jdbc.QueryManager;
|
||||
import com.kingsrook.qqq.backend.module.rdbms.model.metadata.RDBMSBackendMetaData;
|
||||
import org.apache.commons.io.IOUtils;
|
||||
import static junit.framework.Assert.assertNotNull;
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Utility methods for unit tests.
|
||||
**
|
||||
*******************************************************************************/
|
||||
public class TestUtils
|
||||
{
|
||||
|
||||
/*******************************************************************************
|
||||
** Prime a test database (e.g., h2, in-memory)
|
||||
**
|
||||
*******************************************************************************/
|
||||
@SuppressWarnings("unchecked")
|
||||
public static void primeTestDatabase() throws Exception
|
||||
{
|
||||
ConnectionManager connectionManager = new ConnectionManager();
|
||||
Connection connection = connectionManager.getConnection(TestUtils.defineBackend());
|
||||
InputStream primeTestDatabaseSqlStream = TestUtils.class.getResourceAsStream("/prime-test-database.sql");
|
||||
assertNotNull(primeTestDatabaseSqlStream);
|
||||
List<String> lines = (List<String>) IOUtils.readLines(primeTestDatabaseSqlStream);
|
||||
lines = lines.stream().filter(line -> !line.startsWith("-- ")).toList();
|
||||
String joinedSQL = String.join("\n", lines);
|
||||
for(String sql : joinedSQL.split(";"))
|
||||
{
|
||||
QueryManager.executeUpdate(connection, sql);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Run an SQL Query in the test database
|
||||
**
|
||||
*******************************************************************************/
|
||||
public static void runTestSql(String sql, QueryManager.ResultSetProcessor resultSetProcessor) throws Exception
|
||||
{
|
||||
ConnectionManager connectionManager = new ConnectionManager();
|
||||
Connection connection = connectionManager.getConnection(defineBackend());
|
||||
QueryManager.executeStatement(connection, sql, resultSetProcessor);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Define the q-instance for testing (h2 rdbms and 'person' table)
|
||||
**
|
||||
*******************************************************************************/
|
||||
public static QInstance defineInstance()
|
||||
{
|
||||
QInstance qInstance = new QInstance();
|
||||
qInstance.setAuthentication(defineAuthentication());
|
||||
qInstance.addBackend(defineBackend());
|
||||
qInstance.addTable(defineTablePerson());
|
||||
qInstance.addProcess(defineProcessGreetPeople());
|
||||
return (qInstance);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Define the authentication used in standard tests - using 'mock' type.
|
||||
**
|
||||
*******************************************************************************/
|
||||
private static QAuthenticationMetaData defineAuthentication()
|
||||
{
|
||||
return new QAuthenticationMetaData()
|
||||
.withName("mock")
|
||||
.withType(QAuthenticationType.MOCK);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Define the h2 rdbms backend
|
||||
**
|
||||
*******************************************************************************/
|
||||
public static RDBMSBackendMetaData defineBackend()
|
||||
{
|
||||
return (new RDBMSBackendMetaData()
|
||||
.withVendor("h2")
|
||||
.withHostName("mem")
|
||||
.withDatabaseName("test_database")
|
||||
.withUsername("sa")
|
||||
.withPassword("")
|
||||
.withName("default"));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Define the person table
|
||||
**
|
||||
*******************************************************************************/
|
||||
public static QTableMetaData defineTablePerson()
|
||||
{
|
||||
return new QTableMetaData()
|
||||
.withName("person")
|
||||
.withLabel("Person")
|
||||
.withBackendName(defineBackend().getName())
|
||||
.withPrimaryKeyField("id")
|
||||
.withField(new QFieldMetaData("id", QFieldType.INTEGER))
|
||||
.withField(new QFieldMetaData("createDate", QFieldType.DATE_TIME).withBackendName("create_date"))
|
||||
.withField(new QFieldMetaData("modifyDate", QFieldType.DATE_TIME).withBackendName("modify_date"))
|
||||
.withField(new QFieldMetaData("firstName", QFieldType.STRING).withBackendName("first_name"))
|
||||
.withField(new QFieldMetaData("lastName", QFieldType.STRING).withBackendName("last_name"))
|
||||
.withField(new QFieldMetaData("birthDate", QFieldType.DATE).withBackendName("birth_date"))
|
||||
.withField(new QFieldMetaData("email", QFieldType.STRING));
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
** Define the 'greet people' process
|
||||
*******************************************************************************/
|
||||
private static QProcessMetaData defineProcessGreetPeople()
|
||||
{
|
||||
return new QProcessMetaData()
|
||||
.withName("greet")
|
||||
.withTableName("person")
|
||||
.addStep(new QBackendStepMetaData()
|
||||
.withName("prepare")
|
||||
.withCode(new QCodeReference()
|
||||
.withName(MockBackendStep.class.getName())
|
||||
.withCodeType(QCodeType.JAVA)
|
||||
.withCodeUsage(QCodeUsage.BACKEND_STEP)) // todo - needed, or implied in this context?
|
||||
.withInputData(new QFunctionInputMetaData()
|
||||
.withRecordListMetaData(new QRecordListMetaData().withTableName("person"))
|
||||
.withFieldList(List.of(
|
||||
new QFieldMetaData("greetingPrefix", QFieldType.STRING),
|
||||
new QFieldMetaData("greetingSuffix", QFieldType.STRING)
|
||||
)))
|
||||
.withOutputMetaData(new QFunctionOutputMetaData()
|
||||
.withRecordListMetaData(new QRecordListMetaData()
|
||||
.withTableName("person")
|
||||
.addField(new QFieldMetaData("fullGreeting", QFieldType.STRING))
|
||||
)
|
||||
.withFieldList(List.of(new QFieldMetaData("outputMessage", QFieldType.STRING))))
|
||||
);
|
||||
}
|
||||
|
||||
}
|
||||
156
qqq-middleware-picocli/src/test/resources/personQInstance.json
Normal file
156
qqq-middleware-picocli/src/test/resources/personQInstance.json
Normal file
@ -0,0 +1,156 @@
|
||||
{
|
||||
"authentication": {
|
||||
"name": "mock",
|
||||
"type": "mock",
|
||||
"values": null
|
||||
},
|
||||
"tables": {
|
||||
"person": {
|
||||
"name": "person",
|
||||
"label": "Person",
|
||||
"backendName": "default",
|
||||
"primaryKeyField": "id",
|
||||
"fields": {
|
||||
"id": {
|
||||
"name": "id",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "INTEGER",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"createDate": {
|
||||
"name": "createDate",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "DATE_TIME",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"modifyDate": {
|
||||
"name": "modifyDate",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "DATE_TIME",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"firstName": {
|
||||
"name": "firstName",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"lastName": {
|
||||
"name": "lastName",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"birthDate": {
|
||||
"name": "birthDate",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "DATE",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"email": {
|
||||
"name": "email",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"homeState": {
|
||||
"name": "homeState",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": "state"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"possibleValueSources": {
|
||||
"state": {
|
||||
"name": "state",
|
||||
"type": "ENUM",
|
||||
"enumValues": [
|
||||
"IL",
|
||||
"MO"
|
||||
]
|
||||
}
|
||||
},
|
||||
"processes": {
|
||||
"greet": {
|
||||
"name": "greet",
|
||||
"tableName": "person",
|
||||
"functionList": [
|
||||
{
|
||||
"name": "prepare",
|
||||
"label": null,
|
||||
"inputMetaData": {
|
||||
"recordListMetaData": {
|
||||
"tableName": "person",
|
||||
"fields": null
|
||||
},
|
||||
"fieldList": [
|
||||
{
|
||||
"name": "greetingPrefix",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
{
|
||||
"name": "greetingSuffix",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
}
|
||||
]
|
||||
},
|
||||
"outputMetaData": {
|
||||
"recordListMetaData": {
|
||||
"tableName": "person",
|
||||
"fields": {
|
||||
"fullGreeting": {
|
||||
"name": "fullGreeting",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
}
|
||||
}
|
||||
},
|
||||
"fieldList": [
|
||||
{
|
||||
"name": "outputMessage",
|
||||
"label": null,
|
||||
"backendName": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
}
|
||||
]
|
||||
},
|
||||
"code": {
|
||||
"name": "com.kingsrook.qqq.backend.core.interfaces.mock.MockFunctionBody",
|
||||
"codeType": "JAVA",
|
||||
"codeUsage": "FUNCTION"
|
||||
},
|
||||
"outputView": {
|
||||
"messageField": "outputMessage",
|
||||
"recordListView": {
|
||||
"fieldNames": [
|
||||
"id",
|
||||
"firstName",
|
||||
"lastName",
|
||||
"fullGreeting"
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,163 @@
|
||||
{
|
||||
"tables": {
|
||||
"person": {
|
||||
"primaryKeyField": "id",
|
||||
"name": "person",
|
||||
"backendName": "default",
|
||||
"label": "Person",
|
||||
"fields": {
|
||||
"firstName": {
|
||||
"name": "firstName",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"lastName": {
|
||||
"name": "lastName",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"modifyDate": {
|
||||
"name": "modifyDate",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "DATE_TIME",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"homeState": {
|
||||
"name": "homeState",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": "state"
|
||||
},
|
||||
"id": {
|
||||
"name": "id",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "INTEGER",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"birthDate": {
|
||||
"name": "birthDate",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "DATE",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"email": {
|
||||
"name": "email",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"createDate": {
|
||||
"name": "createDate",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "DATE_TIME",
|
||||
"possibleValueSourceName": null
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"processes": {
|
||||
"greet": {
|
||||
"functionList": [
|
||||
{
|
||||
"code": {
|
||||
"codeUsage": "FUNCTION",
|
||||
"codeType": "JAVA",
|
||||
"name": "com.kingsrook.qqq.backend.core.interfaces.mock.MockFunctionBody"
|
||||
},
|
||||
"inputMetaData": {
|
||||
"recordListMetaData": {
|
||||
"fields": null,
|
||||
"tableName": "person"
|
||||
},
|
||||
"fieldList": [
|
||||
{
|
||||
"name": "greetingPrefix",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
{
|
||||
"name": "greetingSuffix",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
}
|
||||
]
|
||||
},
|
||||
"outputMetaData": {
|
||||
"recordListMetaData": {
|
||||
"fields": {
|
||||
"fullGreeting": {
|
||||
"name": "fullGreeting",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
}
|
||||
},
|
||||
"tableName": "person"
|
||||
},
|
||||
"fieldList": [
|
||||
{
|
||||
"name": "outputMessage",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
}
|
||||
]
|
||||
},
|
||||
"outputView": {
|
||||
"messageField": "outputMessage",
|
||||
"recordListView": {
|
||||
"fieldNames": [
|
||||
"id",
|
||||
"firstName",
|
||||
"lastName",
|
||||
"fullGreeting"
|
||||
]
|
||||
}
|
||||
},
|
||||
"name": "prepare",
|
||||
"label": null
|
||||
}
|
||||
],
|
||||
"name": "greet",
|
||||
"tableName": "person"
|
||||
}
|
||||
},
|
||||
"possibleValueSources": {
|
||||
"state": {
|
||||
"name": "state",
|
||||
"type": "ENUM",
|
||||
"enumValues": [
|
||||
"IL",
|
||||
"MO"
|
||||
]
|
||||
}
|
||||
},
|
||||
"backends": {
|
||||
"default": {
|
||||
"values": null,
|
||||
"name": "default",
|
||||
"type": "mock"
|
||||
}
|
||||
},
|
||||
"authentication": {
|
||||
"values": null,
|
||||
"name": "mock",
|
||||
"type": "mock"
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,39 @@
|
||||
--
|
||||
-- QQQ - Low-code Application Framework for Engineers.
|
||||
-- Copyright (C) 2021-2022. Kingsrook, LLC
|
||||
-- 651 N Broad St Ste 205 # 6917 | Middletown DE 19709 | United States
|
||||
-- contact@kingsrook.com
|
||||
-- https://github.com/Kingsrook/
|
||||
--
|
||||
-- This program is free software: you can redistribute it and/or modify
|
||||
-- it under the terms of the GNU Affero General Public License as
|
||||
-- published by the Free Software Foundation, either version 3 of the
|
||||
-- License, or (at your option) any later version.
|
||||
--
|
||||
-- This program is distributed in the hope that it will be useful,
|
||||
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
-- GNU Affero General Public License for more details.
|
||||
--
|
||||
-- You should have received a copy of the GNU Affero General Public License
|
||||
-- along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
--
|
||||
|
||||
DROP TABLE IF EXISTS person;
|
||||
CREATE TABLE person
|
||||
(
|
||||
id INT AUTO_INCREMENT,
|
||||
create_date TIMESTAMP DEFAULT now(),
|
||||
modify_date TIMESTAMP DEFAULT now(),
|
||||
|
||||
first_name VARCHAR(80) NOT NULL,
|
||||
last_name VARCHAR(80) NOT NULL,
|
||||
birth_date DATE,
|
||||
email VARCHAR(250) NOT NULL
|
||||
);
|
||||
|
||||
INSERT INTO person (id, first_name, last_name, birth_date, email) VALUES (1, 'Darin', 'Kelkhoff', '1980-05-31', 'darin.kelkhoff@gmail.com');
|
||||
INSERT INTO person (id, first_name, last_name, birth_date, email) VALUES (2, 'James', 'Maes', '1980-05-15', 'jmaes@mmltholdings.com');
|
||||
INSERT INTO person (id, first_name, last_name, birth_date, email) VALUES (3, 'Tim', 'Chamberlain', '1976-05-28', 'tchamberlain@mmltholdings.com');
|
||||
INSERT INTO person (id, first_name, last_name, birth_date, email) VALUES (4, 'Tyler', 'Samples', '1990-01-01', 'tsamples@mmltholdings.com');
|
||||
INSERT INTO person (id, first_name, last_name, birth_date, email) VALUES (5, 'Garret', 'Richardson', '1981-01-01', 'grichardson@mmltholdings.com');
|
||||
@ -0,0 +1,70 @@
|
||||
{
|
||||
"tables": {
|
||||
"series": {
|
||||
"primaryKeyField": "id",
|
||||
"name": "series",
|
||||
"backendName": "wherenooneMysql",
|
||||
"label": "Person",
|
||||
"fields": {
|
||||
"name": {
|
||||
"name": "name",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"abbreviation": {
|
||||
"name": "abbreviation",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "STRING",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"id": {
|
||||
"name": "id",
|
||||
"backendName": null,
|
||||
"label": null,
|
||||
"type": "INTEGER",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"createDate": {
|
||||
"name": "createDate",
|
||||
"backendName": "create_date",
|
||||
"label": "Create Date",
|
||||
"type": "DATE_TIME",
|
||||
"possibleValueSourceName": null
|
||||
},
|
||||
"modifyDate": {
|
||||
"name": "modifyDate",
|
||||
"backendName": "modify_date",
|
||||
"label": "Modify Date",
|
||||
"type": "DATE_TIME",
|
||||
"possibleValueSourceName": null
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"processes": {
|
||||
},
|
||||
"possibleValueSources": {
|
||||
},
|
||||
"backends": {
|
||||
"wherenooneMysql": {
|
||||
"values": {
|
||||
"vendor": "mysql",
|
||||
"hostName": "localhost",
|
||||
"port": "3306",
|
||||
"databaseName": "wherenoone",
|
||||
"username": "root",
|
||||
"password": "password"
|
||||
},
|
||||
"name": "wherenooneMysql",
|
||||
"type": "rdbms"
|
||||
}
|
||||
},
|
||||
"authentication": {
|
||||
"values": null,
|
||||
"name": "mock",
|
||||
"type": "mock"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user