diff --git a/src/main/java/eu/hbp/mip/controllers/AlgorithmsAPI.java b/src/main/java/eu/hbp/mip/controllers/AlgorithmsAPI.java
index 6385d89d5e1309cda7ea8b28aa5ab0b33f19c2f6..08132000d15bd1f033f9adf625aa24af01c2c542 100644
--- a/src/main/java/eu/hbp/mip/controllers/AlgorithmsAPI.java
+++ b/src/main/java/eu/hbp/mip/controllers/AlgorithmsAPI.java
@@ -8,7 +8,7 @@ import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import eu.hbp.mip.controllers.galaxy.retrofit.RetroFitGalaxyClients;
import eu.hbp.mip.controllers.galaxy.retrofit.RetrofitClientInstance;
-import eu.hbp.mip.models.DTOs.AlgorithmDTO;
+import eu.hbp.mip.models.DTOs.ExaremeAlgorithmDTO;
import eu.hbp.mip.models.DTOs.MIPEngineAlgorithmDTO;
import eu.hbp.mip.models.galaxy.WorkflowDTO;
import eu.hbp.mip.services.ActiveUserService;
@@ -65,24 +65,20 @@ public class AlgorithmsAPI {
@ApiOperation(value = "List all algorithms", response = String.class)
@RequestMapping(method = RequestMethod.GET)
- public ResponseEntity<List<AlgorithmDTO>> getAlgorithms() {
+ public ResponseEntity<List<ExaremeAlgorithmDTO>> getAlgorithms() {
Logger logger = new Logger(activeUserService.getActiveUser().getUsername(), "(GET) /algorithms");
logger.LogUserAction("Executing...");
- LinkedList<AlgorithmDTO> mipengineAlgorithms = getMIPEngineAlgorithms(logger);
+ LinkedList<ExaremeAlgorithmDTO> mipengineAlgorithms = getMIPEngineAlgorithms(logger);
logger.LogUserAction("Loaded " + mipengineAlgorithms.size() + " mipengine algorithms");
- LinkedList<AlgorithmDTO> exaremeAlgorithms = getExaremeAlgorithms(logger);
+ LinkedList<ExaremeAlgorithmDTO> exaremeAlgorithms = getExaremeAlgorithms(logger);
logger.LogUserAction("Loaded " + exaremeAlgorithms.size() + " exareme algorithms");
- LinkedList<AlgorithmDTO> galaxyAlgorithms = getGalaxyWorkflows(logger);
+ LinkedList<ExaremeAlgorithmDTO> galaxyAlgorithms = getGalaxyWorkflows(logger);
logger.LogUserAction("Loaded " + galaxyAlgorithms.size() + " galaxy algorithms");
- LinkedList<AlgorithmDTO> algorithms = new LinkedList<>();
+ LinkedList<ExaremeAlgorithmDTO> algorithms = new LinkedList<>();
if (exaremeAlgorithms != null) {
- //algorithms.addAll(exaremeAlgorithms);
- exaremeAlgorithms.forEach(algorithmDTO -> {
- if(algorithmDTO.getName().equals("LOGISTIC_REGRESSION"))
- algorithms.add(algorithmDTO);
- });
+ algorithms.addAll(exaremeAlgorithms);
} else {
logger.LogUserAction("Getting exareme algorithms failed and returned null");
}
@@ -92,7 +88,7 @@ public class AlgorithmsAPI {
logger.LogUserAction("Getting mipengine algorithms failed and returned null");
}
if (galaxyAlgorithms != null) {
-// algorithms.addAll(galaxyAlgorithms);
+ algorithms.addAll(galaxyAlgorithms);
} else {
logger.LogUserAction("Getting galaxy workflows failed and returned null");
}
@@ -105,8 +101,8 @@ public class AlgorithmsAPI {
}
// Remove any disabled algorithm
- LinkedList<AlgorithmDTO> allowedAlgorithms = new LinkedList<>();
- for (AlgorithmDTO algorithm : algorithms) {
+ LinkedList<ExaremeAlgorithmDTO> allowedAlgorithms = new LinkedList<>();
+ for (ExaremeAlgorithmDTO algorithm : algorithms) {
if (!disabledAlgorithms.contains(algorithm.getName())) {
allowedAlgorithms.add(algorithm);
}
@@ -120,15 +116,15 @@ public class AlgorithmsAPI {
*
* @return a list of AlgorithmDTOs or null if something fails
*/
- public LinkedList<AlgorithmDTO> getExaremeAlgorithms(Logger logger) {
- LinkedList<AlgorithmDTO> algorithms;
+ public LinkedList<ExaremeAlgorithmDTO> getExaremeAlgorithms(Logger logger) {
+ LinkedList<ExaremeAlgorithmDTO> algorithms;
// Get exareme algorithms
try {
StringBuilder response = new StringBuilder();
HTTPUtil.sendGet(exaremeAlgorithmsUrl, response);
algorithms = gson.fromJson(
response.toString(),
- new TypeToken<LinkedList<AlgorithmDTO>>() {
+ new TypeToken<LinkedList<ExaremeAlgorithmDTO>>() {
}.getType()
);
} catch (IOException e) {
@@ -145,7 +141,7 @@ public class AlgorithmsAPI {
*
* @return a list of AlgorithmDTOs or null if something fails
*/
- public LinkedList<AlgorithmDTO> getMIPEngineAlgorithms(Logger logger) {
+ public LinkedList<ExaremeAlgorithmDTO> getMIPEngineAlgorithms(Logger logger) {
LinkedList<MIPEngineAlgorithmDTO> mipEngineAlgorithms;
// Get MIPEngine algorithms
try {
@@ -163,8 +159,7 @@ public class AlgorithmsAPI {
return null;
}
-
- LinkedList<AlgorithmDTO> algorithms = new LinkedList<>();
+ LinkedList<ExaremeAlgorithmDTO> algorithms = new LinkedList<>();
mipEngineAlgorithms.forEach(mipEngineAlgorithm -> algorithms.add(mipEngineAlgorithm.convertToAlgorithmDTO()));
logger.LogUserAction("Completed, returned " + algorithms.size() + " algorithms.");
@@ -176,7 +171,7 @@ public class AlgorithmsAPI {
*
* @return a list of AlgorithmDTOs or null if something fails
*/
- public LinkedList<AlgorithmDTO> getGalaxyWorkflows(Logger logger) {
+ public LinkedList<ExaremeAlgorithmDTO> getGalaxyWorkflows(Logger logger) {
List<Workflow> workflowList;
try {
// Get all the workflows with the galaxy client
@@ -215,7 +210,7 @@ public class AlgorithmsAPI {
logger.LogUserAction("Workflows fetched: " + workflows.size());
// Convert the workflows to algorithms
- LinkedList<AlgorithmDTO> algorithms = new LinkedList<>();
+ LinkedList<ExaremeAlgorithmDTO> algorithms = new LinkedList<>();
for (WorkflowDTO workflow : workflows) {
logger.LogUserAction("Converting workflow: " + workflow);
diff --git a/src/main/java/eu/hbp/mip/models/DAOs/ExperimentDAO.java b/src/main/java/eu/hbp/mip/models/DAOs/ExperimentDAO.java
index 585bd8bd6694275d341fe1aea19f82f3105d97ea..4e206fae0d3605e6b0ffcaab5fded486eef25d45 100644
--- a/src/main/java/eu/hbp/mip/models/DAOs/ExperimentDAO.java
+++ b/src/main/java/eu/hbp/mip/models/DAOs/ExperimentDAO.java
@@ -3,7 +3,7 @@ package eu.hbp.mip.models.DAOs;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.google.gson.Gson;
import com.google.gson.annotations.Expose;
-import eu.hbp.mip.models.DTOs.AlgorithmDTO;
+import eu.hbp.mip.models.DTOs.ExaremeAlgorithmDTO;
import eu.hbp.mip.models.DTOs.ExperimentDTO;
import eu.hbp.mip.utils.JsonConverters;
import io.swagger.annotations.ApiModel;
@@ -98,7 +98,7 @@ public class ExperimentDAO {
public ExperimentDTO convertToDTO(boolean includeResult)
{
ExperimentDTO experimentDTO = new ExperimentDTO();
- experimentDTO.setAlgorithm(JsonConverters.convertJsonStringToObject(this.algorithm, AlgorithmDTO.class));
+ experimentDTO.setAlgorithm(JsonConverters.convertJsonStringToObject(this.algorithm, ExaremeAlgorithmDTO.class));
experimentDTO.setCreated(this.created);
experimentDTO.setUpdated(this.updated);
experimentDTO.setFinished(this.finished);
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/AlgorithmDTO.java b/src/main/java/eu/hbp/mip/models/DTOs/AlgorithmDTO.java
deleted file mode 100644
index 6d70c021567ddf258f2dc4e716cb030f27949518..0000000000000000000000000000000000000000
--- a/src/main/java/eu/hbp/mip/models/DTOs/AlgorithmDTO.java
+++ /dev/null
@@ -1,162 +0,0 @@
-package eu.hbp.mip.models.DTOs;
-
-import com.google.gson.annotations.SerializedName;
-import eu.hbp.mip.utils.JsonConverters;
-import lombok.Getter;
-import lombok.Setter;
-
-import java.util.*;
-
-@Getter
-@Setter
-public class AlgorithmDTO {
-
- @SerializedName("name")
- private String name;
-
- @SerializedName("desc")
- private String desc;
-
- @SerializedName("label")
- private String label;
-
- @SerializedName("type")
- private String type;
-
- @SerializedName("parameters")
- private List<AlgorithmParamDTO> parameters;
-
- @Getter
- @Setter
- public static class AlgorithmParamDTO {
- @SerializedName("name")
- private String name;
-
- @SerializedName("desc")
- private String desc;
-
- @SerializedName("label")
- private String label;
-
- @SerializedName("type")
- private String type;
-
- @SerializedName("columnValuesSQLType")
- private String columnValuesSQLType;
-
- @SerializedName("columnValuesIsCategorical")
- private String columnValuesIsCategorical;
-
- @SerializedName("value")
- private String value;
-
- @SerializedName("defaultValue")
- private String defaultValue;
-
- @SerializedName("valueType")
- private String valueType;
-
- @SerializedName("valueNotBlank")
- private String valueNotBlank;
-
- @SerializedName("valueMultiple")
- private String valueMultiple;
-
- @SerializedName("valueMin")
- private String valueMin;
-
- @SerializedName("valueMax")
- private String valueMax;
-
- @SerializedName("valueEnumerations")
- private List<String> valueEnumerations;
- }
-
- @Getter
- @Setter
- public static class Rule
- {
- @SerializedName("id")
- private String id;
-
- @SerializedName("type")
- private String type;
-
- @SerializedName("operator")
- private String operator;
-
- @SerializedName("value")
- private Object value;
-
- public Rule(String id, String type, String operator, Object value) {
- this.id = id;
- this.type = type;
- this.operator = operator;
- this.value = value;
- }
- }
-
- @Getter
- @Setter
- public static class Filter
- {
- @SerializedName("condition")
- private String condition;
-
- @SerializedName("rules")
- private List<Object> rules;
-
- @SerializedName("valid")
- private boolean valid;
-
- public Filter(String condition, List<Object> rules, boolean valid) {
- this.condition = condition;
- this.rules = rules;
- this.valid = valid;
- }
- }
-
-
- public MIPEngineBody convertToMIPEngineBody()
- {
- MIPEngineBody mipEngineBody = new MIPEngineBody();
- MIPEngineBody.InputData inputData = new MIPEngineBody.InputData();
- Hashtable<String, Object> mipEngineParameters = new Hashtable<>();
-
- List<Object> rules = new ArrayList<>();
- this.parameters.forEach(parameter -> {
-
- if(parameter.getName().equals("x")) {
- System.out.println("x");
- List<String> x = Arrays.asList(parameter.getValue().split(","));
- x.forEach(column -> rules.add(new Rule(column, parameter.getColumnValuesSQLType(), "is_not_null", null)));
- inputData.setX(x);
- }
- else if(parameter.getName().equals("y")) {
- List<String> y = Arrays.asList(parameter.getValue().split(","));
- y.forEach(column -> rules.add(new Rule(column, parameter.getColumnValuesSQLType(), "is_not_null", null)));
- inputData.setY(y);
- }
- else if(parameter.getName().equals("dataset")){
- List<String> datasets = Arrays.asList(parameter.getValue().split(","));
- rules.add(new Rule("dataset","string", "in", datasets));
- inputData.setDatasets(datasets);
- }
- else if(parameter.getName().equals("pathology"))
- inputData.setPathology(parameter.getValue());
-
- else if(parameter.getName().equals("filter")){
- if (parameter.getValue() != "")
- rules.add(JsonConverters.convertJsonStringToObject(parameter.getValue(), Filter.class));
- }
- else{
- mipEngineParameters.put(parameter.getName(), Arrays.asList(parameter.getValue().split(",")));
- }
- });
- Filter filter = new Filter("AND", rules, true);
- inputData.setFilters(filter);
- mipEngineBody.setInputdata(inputData);
- mipEngineBody.setParameters(mipEngineParameters);
- return mipEngineBody;
- }
-}
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmDTO.java b/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmDTO.java
new file mode 100644
index 0000000000000000000000000000000000000000..b56e16bc7130ad30bc4c3e5739af17908419a4a5
--- /dev/null
+++ b/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmDTO.java
@@ -0,0 +1,89 @@
+package eu.hbp.mip.models.DTOs;
+
+import com.google.gson.annotations.SerializedName;
+import eu.hbp.mip.utils.JsonConverters;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.*;
+
+@Getter
+@Setter
+public class ExaremeAlgorithmDTO {
+
+ @SerializedName("name")
+ private String name;
+
+ @SerializedName("desc")
+ private String desc;
+
+ @SerializedName("label")
+ private String label;
+
+ @SerializedName("type")
+ private String type;
+
+ @SerializedName("parameters")
+ private List<ExaremeAlgorithmRequestDTO> parameters;
+
+
+ @Getter
+ @Setter
+ @AllArgsConstructor
+ class Rule
+ {
+ @SerializedName("id")
+ private String id;
+
+ @SerializedName("type")
+ private String type;
+
+ @SerializedName("operator")
+ private String operator;
+
+ @SerializedName("value")
+ private Object value;
+ }
+ public MIPEngineExperimentDTO convertToMIPEngineBody()
+ {
+ MIPEngineExperimentDTO mipEngineExperimentDTO = new MIPEngineExperimentDTO();
+ MIPEngineExperimentDTO.InputData inputData = new MIPEngineExperimentDTO.InputData();
+ Hashtable<String, Object> mipEngineParameters = new Hashtable<>();
+
+ List<Object> rules = new ArrayList<>();
+ this.parameters.forEach(parameter -> {
+
+ if(parameter.getName().equals("x")) {
+ List<String> x = Arrays.asList(parameter.getValue().split(","));
+ x.forEach(column -> rules.add(new Rule(column, parameter.getColumnValuesSQLType(), "is_not_null", null)));
+ inputData.setX(x);
+ }
+ else if(parameter.getName().equals("y")) {
+ List<String> y = Arrays.asList(parameter.getValue().split(","));
+ y.forEach(column -> rules.add(new Rule(column, parameter.getColumnValuesSQLType(), "is_not_null", null)));
+ inputData.setY(y);
+ }
+ else if(parameter.getName().equals("dataset")){
+ List<String> datasets = Arrays.asList(parameter.getValue().split(","));
+ rules.add(new Rule("dataset","string", "in", datasets));
+ inputData.setDatasets(datasets);
+ }
+ else if(parameter.getName().equals("pathology"))
+ inputData.setPathology(parameter.getValue());
+
+ else if(parameter.getName().equals("filter")){
+ if (parameter.getValue() != "")
+ rules.add(JsonConverters.convertJsonStringToObject(parameter.getValue(), MIPEngineExperimentDTO.Filter.class));
+ }
+ else{
+ mipEngineParameters.put(parameter.getName(), Arrays.asList(parameter.getValue().split(",")));
+ }
+ });
+ MIPEngineExperimentDTO.Filter filter = new MIPEngineExperimentDTO.Filter("AND", rules, true);
+ inputData.setFilters(filter);
+ mipEngineExperimentDTO.setInputdata(inputData);
+ mipEngineExperimentDTO.setParameters(mipEngineParameters);
+ return mipEngineExperimentDTO;
+ }
+}
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmRequestDTO.java b/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmRequestDTO.java
new file mode 100644
index 0000000000000000000000000000000000000000..84e275ec8663d7e90e6420f77a33ff899fe5773d
--- /dev/null
+++ b/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmRequestDTO.java
@@ -0,0 +1,53 @@
+package eu.hbp.mip.models.DTOs;
+
+import com.google.gson.annotations.SerializedName;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+public class ExaremeAlgorithmRequestDTO {
+ @SerializedName("name")
+ private String name;
+
+ @SerializedName("desc")
+ private String desc;
+
+ @SerializedName("label")
+ private String label;
+
+ @SerializedName("type")
+ private String type;
+
+ @SerializedName("columnValuesSQLType")
+ private String columnValuesSQLType;
+
+ @SerializedName("columnValuesIsCategorical")
+ private String columnValuesIsCategorical;
+
+ @SerializedName("value")
+ private String value;
+
+ @SerializedName("defaultValue")
+ private String defaultValue;
+
+ @SerializedName("valueType")
+ private String valueType;
+
+ @SerializedName("valueNotBlank")
+ private String valueNotBlank;
+
+ @SerializedName("valueMultiple")
+ private String valueMultiple;
+
+ @SerializedName("valueMin")
+ private String valueMin;
+
+ @SerializedName("valueMax")
+ private String valueMax;
+
+ @SerializedName("valueEnumerations")
+ private List<String> valueEnumerations;
+}
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmResultDTO.java b/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmResultDTO.java
new file mode 100644
index 0000000000000000000000000000000000000000..ca556bb7341c838271c03cd1d75249d2fba59f37
--- /dev/null
+++ b/src/main/java/eu/hbp/mip/models/DTOs/ExaremeAlgorithmResultDTO.java
@@ -0,0 +1,17 @@
+package eu.hbp.mip.models.DTOs;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class ExaremeAlgorithmResultDTO {
+ private int code;
+ private List<Object> results;
+}
+
+
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/ExperimentDTO.java b/src/main/java/eu/hbp/mip/models/DTOs/ExperimentDTO.java
index e64c6f75e7d7a4d7aafa8ba93d38f9d3edf6bf19..765c20144a3a376124d717980acff6dd8991543a 100644
--- a/src/main/java/eu/hbp/mip/models/DTOs/ExperimentDTO.java
+++ b/src/main/java/eu/hbp/mip/models/DTOs/ExperimentDTO.java
@@ -22,10 +22,12 @@ public class ExperimentDTO {
private Date finished;
private Boolean shared;
private Boolean viewed;
+ // Result is a list of objects because there is a limitation that java has in types.
+ // Exareme has result in the type of a List<HashMap<String, Object>>
+ // Galaxy has result in the type of a List<HashMap<String, List<Object>>>
+ //And there is no generic type that describes either an object or a list of objects
private List<Object> result;
private ExperimentDAO.Status status;
- private AlgorithmDTO algorithm;
+ private ExaremeAlgorithmDTO algorithm;
- public ExperimentDTO() {
- }
}
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineAlgorithmDTO.java b/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineAlgorithmDTO.java
index d391492d7615e6ef5892fa78c5a83227207d4afb..ada09db3bc611bd273b59109a64a450db404d567 100644
--- a/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineAlgorithmDTO.java
+++ b/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineAlgorithmDTO.java
@@ -33,7 +33,7 @@ public class MIPEngineAlgorithmDTO {
private String crossvalidation;
@SerializedName("inputdata")
- private Hashtable<String, InputDataParamDTO> inputdata;
+ private InputdataDTO inputdata;
@Getter
@Setter
@@ -66,26 +66,55 @@ public class MIPEngineAlgorithmDTO {
@SerializedName("enums")
private List<String> enums;
- public AlgorithmDTO.AlgorithmParamDTO convertToAlgorithmParamDTO(String name) throws Exception {
- AlgorithmDTO.AlgorithmParamDTO algorithmParamDTO = new AlgorithmDTO.AlgorithmParamDTO();
- algorithmParamDTO.setName(name);
- algorithmParamDTO.setDesc(this.desc);
- algorithmParamDTO.setValueType(this.type);
- algorithmParamDTO.setType("other");
- algorithmParamDTO.setDefaultValue(this.default_value);
- algorithmParamDTO.setValueNotBlank(this.notblank);
- algorithmParamDTO.setLabel(this.label);
- algorithmParamDTO.setValueEnumerations(this.enums);
- algorithmParamDTO.setValueMultiple(this.multiple);
- algorithmParamDTO.setValueMin(this.min);
- algorithmParamDTO.setValueMax(this.max);
- return algorithmParamDTO;
+ public ExaremeAlgorithmRequestDTO convertToexaremeAlgorithmRequestDTO(String name) throws Exception {
+ ExaremeAlgorithmRequestDTO exaremeAlgorithmRequestDTO = new ExaremeAlgorithmRequestDTO();
+ exaremeAlgorithmRequestDTO.setName(name);
+ exaremeAlgorithmRequestDTO.setDesc(this.desc);
+ exaremeAlgorithmRequestDTO.setValueType(this.type);
+ exaremeAlgorithmRequestDTO.setType("other");
+ exaremeAlgorithmRequestDTO.setDefaultValue(this.default_value);
+ exaremeAlgorithmRequestDTO.setValueNotBlank(this.notblank);
+ exaremeAlgorithmRequestDTO.setLabel(this.label);
+ exaremeAlgorithmRequestDTO.setValueEnumerations(this.enums);
+ exaremeAlgorithmRequestDTO.setValueMultiple(this.multiple);
+ exaremeAlgorithmRequestDTO.setValueMin(this.min);
+ exaremeAlgorithmRequestDTO.setValueMax(this.max);
+ return exaremeAlgorithmRequestDTO;
}
}
@Getter
@Setter
- public static class InputDataParamDTO {
+ public static class InputdataDTO {
+ @SerializedName("x")
+ private InputDataDetailDTO x;
+
+ @SerializedName("y")
+ private InputDataDetailDTO y;
+
+ @SerializedName("pathology")
+ private InputDataDetailDTO pathology;
+
+ @SerializedName("datasets")
+ private InputDataDetailDTO datasets;
+
+ @SerializedName("filter")
+ private InputDataDetailDTO filter;
+
+ public List<ExaremeAlgorithmRequestDTO> convertToAlgorithmRequestDTOs() throws Exception {
+ List<ExaremeAlgorithmRequestDTO> exaremeAlgorithmRequestDTOS = new ArrayList<>();
+ exaremeAlgorithmRequestDTOS.add(this.x.convertToExaremeAlgorithmRequestDTO("x"));
+ exaremeAlgorithmRequestDTOS.add(this.y.convertToExaremeAlgorithmRequestDTO("y"));
+ exaremeAlgorithmRequestDTOS.add(this.x.convertToExaremeAlgorithmRequestDTO("pathology"));
+ exaremeAlgorithmRequestDTOS.add(this.datasets.convertToExaremeAlgorithmRequestDTO("dataset"));
+ exaremeAlgorithmRequestDTOS.add(this.filter.convertToExaremeAlgorithmRequestDTO("filter"));
+ return exaremeAlgorithmRequestDTOS;
+ }
+ }
+
+ @Getter
+ @Setter
+ public static class InputDataDetailDTO {
@SerializedName("stattypes")
private List<String> stattypes;
@@ -108,32 +137,27 @@ public class MIPEngineAlgorithmDTO {
@SerializedName("desc")
private String desc;
- public AlgorithmDTO.AlgorithmParamDTO convertToAlgorithmParamDTO(String name) throws Exception {
- AlgorithmDTO.AlgorithmParamDTO algorithmParamDTO = new AlgorithmDTO.AlgorithmParamDTO();
- algorithmParamDTO.setName(name);
- algorithmParamDTO.setDesc(this.desc);
-
- if(name.equals("datasets") || name.equals("filter") || name.equals("pathology")){
- if(name.equals("datasets")){
- algorithmParamDTO.setName("dataset");
- }
- algorithmParamDTO.setValueType(this.types.get(0));
- algorithmParamDTO.setType(algorithmParamDTO.getName());
+ public ExaremeAlgorithmRequestDTO convertToExaremeAlgorithmRequestDTO(String name) throws Exception {
+ ExaremeAlgorithmRequestDTO exaremeAlgorithmRequestDTO = new ExaremeAlgorithmRequestDTO();
+ exaremeAlgorithmRequestDTO.setName(name);
+ exaremeAlgorithmRequestDTO.setDesc(this.desc);
+ exaremeAlgorithmRequestDTO.setValue("");
+ exaremeAlgorithmRequestDTO.setValueNotBlank(this.notblank);
+ exaremeAlgorithmRequestDTO.setValueMultiple(this.multiple);
+ String[] hidden = {"x","y","dataset", "filter","pathology","centers","formula"};
+ exaremeAlgorithmRequestDTO.setLabel(Arrays.asList(hidden).contains(exaremeAlgorithmRequestDTO.getName()) ? exaremeAlgorithmRequestDTO.getName():this.label);
+ if(name.equals("dataset") || name.equals("filter") || name.equals("pathology")){
+ exaremeAlgorithmRequestDTO.setValueType(this.types.get(0));
+ exaremeAlgorithmRequestDTO.setType(exaremeAlgorithmRequestDTO.getName());
}
else{
- algorithmParamDTO.setType("column");
- algorithmParamDTO.setColumnValuesSQLType(String.join(", ", this.types));
- algorithmParamDTO.setColumnValuesIsCategorical(getColumnValuesIsCategorical(this.stattypes));
+ exaremeAlgorithmRequestDTO.setType("column");
+ exaremeAlgorithmRequestDTO.setColumnValuesSQLType(String.join(", ", this.types));
+ exaremeAlgorithmRequestDTO.setColumnValuesIsCategorical(getColumnValuesIsCategorical(this.stattypes));
}
- algorithmParamDTO.setValue("");
- algorithmParamDTO.setValueNotBlank(this.notblank);
- algorithmParamDTO.setValueMultiple(this.multiple);
- String[] hidden = {"x","y","dataset", "filter","pathology","centers","formula"};
- algorithmParamDTO.setLabel(Arrays.asList(hidden).contains(algorithmParamDTO.getName()) ? algorithmParamDTO.getName():this.label);
- System.out.println("-------------------------------------------------------->");
- System.out.println(JsonConverters.convertObjectToJsonString(algorithmParamDTO));
- return algorithmParamDTO;
+ return exaremeAlgorithmRequestDTO;
}
+
private String getColumnValuesIsCategorical(List<String> stattypes) throws Exception {
if (stattypes.contains("nominal") && stattypes.contains("numerical")){
@@ -151,31 +175,28 @@ public class MIPEngineAlgorithmDTO {
}
}
- public AlgorithmDTO convertToAlgorithmDTO()
+ public ExaremeAlgorithmDTO convertToAlgorithmDTO()
{
- AlgorithmDTO algorithmDTO = new AlgorithmDTO();
- algorithmDTO.setName(this.name.toUpperCase());
- algorithmDTO.setLabel(this.label);
- algorithmDTO.setDesc(this.desc);
- algorithmDTO.setType("mipengine");
- List<AlgorithmDTO.AlgorithmParamDTO> parameters = new ArrayList<>();
- this.inputdata.forEach((name, inputDataParamDTO) -> {
- try {
- AlgorithmDTO.AlgorithmParamDTO parameter = inputDataParamDTO.convertToAlgorithmParamDTO(name);
- parameters.add(parameter);
- } catch (Exception e) {
- e.printStackTrace();
- }
- });
+ ExaremeAlgorithmDTO exaremeAlgorithmDTO = new ExaremeAlgorithmDTO();
+ exaremeAlgorithmDTO.setName(this.name.toUpperCase());
+ exaremeAlgorithmDTO.setLabel(this.label);
+ exaremeAlgorithmDTO.setDesc(this.desc);
+ exaremeAlgorithmDTO.setType("mipengine");
+ List<ExaremeAlgorithmRequestDTO> parameters = new ArrayList<>();
+ try {
+ parameters.addAll(this.inputdata.convertToAlgorithmRequestDTOs());
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
this.parameters.forEach((name, parameterDTO) -> {
try {
- AlgorithmDTO.AlgorithmParamDTO parameter = parameterDTO.convertToAlgorithmParamDTO(name);
+ ExaremeAlgorithmRequestDTO parameter = parameterDTO.convertToexaremeAlgorithmRequestDTO(name);
parameters.add(parameter);
} catch (Exception e) {
e.printStackTrace();
}
});
- algorithmDTO.setParameters(parameters);
- return algorithmDTO;
+ exaremeAlgorithmDTO.setParameters(parameters);
+ return exaremeAlgorithmDTO;
}
}
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineAlgorithmResultDTO.java b/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineAlgorithmResultDTO.java
new file mode 100644
index 0000000000000000000000000000000000000000..087adb1f84072ba0188d0b8e300ba0d5ee535e20
--- /dev/null
+++ b/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineAlgorithmResultDTO.java
@@ -0,0 +1,23 @@
+package eu.hbp.mip.models.DTOs;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.HashMap;
+import java.util.List;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class MIPEngineAlgorithmResultDTO {
+ private final String title;
+ private final List<MIPEngineTabularVisualizationDTO.Field> columns;
+ private final List<List<Object>> data;
+
+ public MIPEngineTabularVisualizationDTO convertToVisualization() {
+ HashMap<String, List<MIPEngineTabularVisualizationDTO.Field>> schema = new HashMap<>();
+ schema.put("fields", columns);
+ return new MIPEngineTabularVisualizationDTO(this.title, "tabular-data-resource", schema, this.data);
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineBody.java b/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineExperimentDTO.java
similarity index 64%
rename from src/main/java/eu/hbp/mip/models/DTOs/MIPEngineBody.java
rename to src/main/java/eu/hbp/mip/models/DTOs/MIPEngineExperimentDTO.java
index 1572eb7daed817717bfff4c03d1a8524e2e498eb..46b7df8982f1e8d3f50ac31517489acdf22a8a54 100644
--- a/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineBody.java
+++ b/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineExperimentDTO.java
@@ -1,6 +1,7 @@
package eu.hbp.mip.models.DTOs;
import com.google.gson.annotations.SerializedName;
+import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
@@ -9,7 +10,7 @@ import java.util.List;
@Getter
@Setter
-public class MIPEngineBody {
+public class MIPEngineExperimentDTO {
@SerializedName("inputdata")
private InputData inputdata;
@SerializedName("parameters")
@@ -23,10 +24,25 @@ public class MIPEngineBody {
@SerializedName("datasets")
private List<String> datasets;
@SerializedName("filters")
- private AlgorithmDTO.Filter filters;
+ private Filter filters;
@SerializedName("x")
private List<String> x;
@SerializedName("y")
private List<String> y;
}
+
+ @Getter
+ @Setter
+ @AllArgsConstructor
+ public static class Filter
+ {
+ @SerializedName("condition")
+ private String condition;
+
+ @SerializedName("rules")
+ private List<Object> rules;
+
+ @SerializedName("valid")
+ private boolean valid;
+ }
}
diff --git a/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineTabularVisualizationDTO.java b/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineTabularVisualizationDTO.java
new file mode 100644
index 0000000000000000000000000000000000000000..7be3fad336e3bf4642f09c6985909d38fb2c4abc
--- /dev/null
+++ b/src/main/java/eu/hbp/mip/models/DTOs/MIPEngineTabularVisualizationDTO.java
@@ -0,0 +1,27 @@
+package eu.hbp.mip.models.DTOs;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.HashMap;
+import java.util.List;
+
+@Getter
+@Setter
+@AllArgsConstructor
+public class MIPEngineTabularVisualizationDTO {
+ private final String name;
+ private final String profile;
+ private final HashMap<String, List<Field>> schema;
+ private final List<List<Object>> data;
+
+ @Getter
+ @Setter
+ @AllArgsConstructor
+ public static class Field {
+ private final String name;
+ private final String type;
+ }
+}
+
diff --git a/src/main/java/eu/hbp/mip/models/galaxy/WorkflowDTO.java b/src/main/java/eu/hbp/mip/models/galaxy/WorkflowDTO.java
index 496ee2dfebf50324b1443774cc48edd4e32c2de0..edc18117d6660b490a2681cd54b671692ef140e3 100644
--- a/src/main/java/eu/hbp/mip/models/galaxy/WorkflowDTO.java
+++ b/src/main/java/eu/hbp/mip/models/galaxy/WorkflowDTO.java
@@ -2,7 +2,8 @@ package eu.hbp.mip.models.galaxy;
import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
-import eu.hbp.mip.models.DTOs.AlgorithmDTO;
+import eu.hbp.mip.models.DTOs.ExaremeAlgorithmDTO;
+import eu.hbp.mip.models.DTOs.ExaremeAlgorithmRequestDTO;
import java.util.*;
@@ -103,29 +104,29 @@ public class WorkflowDTO {
}
}
- public AlgorithmDTO convertToAlgorithmDTO() {
+ public ExaremeAlgorithmDTO convertToAlgorithmDTO() {
- AlgorithmDTO algorithmDTO = new AlgorithmDTO();
+ ExaremeAlgorithmDTO exaremeAlgorithmDTO = new ExaremeAlgorithmDTO();
// Transfer workflow information
- algorithmDTO.setName(id);
- algorithmDTO.setDesc("");
- algorithmDTO.setLabel(name);
- algorithmDTO.setType("workflow");
+ exaremeAlgorithmDTO.setName(id);
+ exaremeAlgorithmDTO.setDesc("");
+ exaremeAlgorithmDTO.setLabel(name);
+ exaremeAlgorithmDTO.setType("workflow");
// Transfer workflow parameters information
- List<AlgorithmDTO.AlgorithmParamDTO> algorithmParams = new LinkedList<>();
+ List<ExaremeAlgorithmRequestDTO> algorithmParams = new LinkedList<>();
Gson gson = new Gson();
for (Map.Entry<String, WorkflowInputDTO> workflowInput : getInputs().entrySet()) {
// Convert the annotation to algorithm Parameter
- AlgorithmDTO.AlgorithmParamDTO algorithmParam;
+ ExaremeAlgorithmRequestDTO algorithmParam;
if (steps.get(workflowInput.getKey()).getAnnotation() != null) {
algorithmParam = gson.fromJson(steps.get(workflowInput.getKey()).getAnnotation(),
- AlgorithmDTO.AlgorithmParamDTO.class);
+ ExaremeAlgorithmRequestDTO.class);
} else {
// If annotation is not provided, auto-fill some information
- algorithmParam = new AlgorithmDTO.AlgorithmParamDTO();
+ algorithmParam = new ExaremeAlgorithmRequestDTO();
// When the constraints are not known, set the most relaxed constraints
algorithmParam.setDesc("");
algorithmParam.setValue("");
@@ -154,9 +155,9 @@ public class WorkflowDTO {
algorithmParams.add(algorithmParam);
}
- algorithmDTO.setParameters(algorithmParams);
+ exaremeAlgorithmDTO.setParameters(algorithmParams);
- return algorithmDTO;
+ return exaremeAlgorithmDTO;
}
}
diff --git a/src/main/java/eu/hbp/mip/services/ExperimentService.java b/src/main/java/eu/hbp/mip/services/ExperimentService.java
index a48beb3aa9a975d71ad3c1bbeb0dad03cc191ebc..587fc7e63adc0a23a182e740028e4b31a1e66e02 100644
--- a/src/main/java/eu/hbp/mip/services/ExperimentService.java
+++ b/src/main/java/eu/hbp/mip/services/ExperimentService.java
@@ -15,9 +15,7 @@ import eu.hbp.mip.controllers.galaxy.retrofit.RetroFitGalaxyClients;
import eu.hbp.mip.controllers.galaxy.retrofit.RetrofitClientInstance;
import eu.hbp.mip.models.DAOs.ExperimentDAO;
import eu.hbp.mip.models.DAOs.UserDAO;
-import eu.hbp.mip.models.DTOs.AlgorithmDTO;
-import eu.hbp.mip.models.DTOs.ExperimentDTO;
-import eu.hbp.mip.models.DTOs.MIPEngineBody;
+import eu.hbp.mip.models.DTOs.*;
import eu.hbp.mip.models.galaxy.GalaxyWorkflowResult;
import eu.hbp.mip.models.galaxy.PostWorkflowToGalaxyDtoResponse;
import eu.hbp.mip.repositories.ExperimentRepository;
@@ -27,9 +25,6 @@ import eu.hbp.mip.utils.Exceptions.*;
import eu.hbp.mip.utils.HTTPUtil;
import eu.hbp.mip.utils.JsonConverters;
import eu.hbp.mip.utils.Logger;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-import lombok.Setter;
import org.codehaus.jettison.json.JSONException;
import org.codehaus.jettison.json.JSONObject;
import org.springframework.beans.factory.annotation.Value;
@@ -236,12 +231,12 @@ public class ExperimentService {
logger.LogUserAction("Completed, returning: " + experimentDTO);
// Results are stored in the experiment object
- ExperimentResult experimentResult = runExperiment(experimentDTO, logger);
+ ExaremeAlgorithmResultDTO exaremeAlgorithmResultDTO = runExperiment(experimentDTO, logger);
- logger.LogUserAction("Experiment with uuid: " + experimentDTO.getUuid() + "gave response code: " + experimentResult.getCode() + " and result: " + experimentResult.getResults());
+ logger.LogUserAction("Experiment with uuid: " + experimentDTO.getUuid() + "gave response code: " + exaremeAlgorithmResultDTO.getCode() + " and result: " + exaremeAlgorithmResultDTO.getResults());
- experimentDTO.setResult((experimentResult.getCode() >= 400) ? null : experimentResult.getResults());
- experimentDTO.setStatus((experimentResult.getCode() >= 400) ? ExperimentDAO.Status.error : ExperimentDAO.Status.success);
+ experimentDTO.setResult((exaremeAlgorithmResultDTO.getCode() >= 400) ? null : exaremeAlgorithmResultDTO.getResults());
+ experimentDTO.setStatus((exaremeAlgorithmResultDTO.getCode() >= 400) ? ExperimentDAO.Status.error : ExperimentDAO.Status.success);
return experimentDTO;
}
@@ -400,7 +395,7 @@ public class ExperimentService {
private String getDatasetFromExperimentParameters(ExperimentDTO experimentDTO, Logger logger) {
String experimentDatasets = null;
- for (AlgorithmDTO.AlgorithmParamDTO parameter : experimentDTO.getAlgorithm().getParameters()) {
+ for (ExaremeAlgorithmRequestDTO parameter : experimentDTO.getAlgorithm().getParameters()) {
if (parameter.getLabel().equals("dataset")) {
experimentDatasets = parameter.getValue();
break;
@@ -510,14 +505,14 @@ public class ExperimentService {
return JsonConverters.convertObjectToJsonString(finalJsonObject);
}
- private List<Object> formattingMIPEngienResult(String result) {
- MIPVisualization mipVisualization = JsonConverters.convertJsonStringToObject(result, MIPVisualization.class);
+ private ExaremeAlgorithmResultDTO convertMIPEngineResultToExaremeAlgorithmResult(int code, String result) {
+ MIPEngineAlgorithmResultDTO mipVisualization = JsonConverters.convertJsonStringToObject(result, MIPEngineAlgorithmResultDTO.class);
LinkedTreeMap<String,Object> data = new LinkedTreeMap<>();
data.put("data", mipVisualization.convertToVisualization());
data.put("type", "application/vnd.dataresource+json");
List<Object> finalObject = new ArrayList<>();
finalObject.add(data);
- return finalObject;
+ return new ExaremeAlgorithmResultDTO(code, finalObject);
}
/**
@@ -526,7 +521,7 @@ public class ExperimentService {
* @param experimentDTO is the request with the experiment information
* @return the result of experiment as well as the http status that was retrieved
*/
- public ExperimentResult runExperiment(ExperimentDTO experimentDTO, Logger logger) {
+ public ExaremeAlgorithmResultDTO runExperiment(ExperimentDTO experimentDTO, Logger logger) {
// Algorithm type
String algorithmType = experimentDTO.getAlgorithm().getType();
@@ -536,14 +531,14 @@ public class ExperimentService {
// Run with the appropriate engine
if (algorithmType.equals("mipengine")) {
- MIPEngineBody mipEngineBody = experimentDTO.getAlgorithm().convertToMIPEngineBody();
- String body = JsonConverters.convertObjectToJsonString(mipEngineBody);
+ MIPEngineExperimentDTO mipEngineExperimentDTO = experimentDTO.getAlgorithm().convertToMIPEngineBody();
+ String body = JsonConverters.convertObjectToJsonString(mipEngineExperimentDTO);
String url = mipengineAlgorithmsUrl + "/" + algorithmName.toLowerCase();
logger.LogUserAction("url: " + url + ", body: " + body);
logger.LogUserAction("Algorithm runs on MIPEngine.");
return runMIPEngineExperiment(url, body);
} else {
- List<AlgorithmDTO.AlgorithmParamDTO> algorithmParameters
+ List<ExaremeAlgorithmRequestDTO> algorithmParameters
= experimentDTO.getAlgorithm().getParameters();
String body = gson.toJson(algorithmParameters);
String url = queryExaremeUrl + "/" + algorithmName;
@@ -561,7 +556,7 @@ public class ExperimentService {
* @param body is the parameters of the algorithm
* @return the result of exareme as well as the http status that was retrieved
*/
- public ExperimentResult runExaremeExperiment(String url, String body) {
+ public ExaremeAlgorithmResultDTO runExaremeExperiment(String url, String body) {
StringBuilder results = new StringBuilder();
int code;
@@ -572,10 +567,12 @@ public class ExperimentService {
}
// Results are stored in the experiment object
- ExperimentDTO experimentDTOWithOnlyResult = JsonConverters.convertJsonStringToObject(String.valueOf(results), ExperimentDTO.class);
- List<Object> resultDTOS = experimentDTOWithOnlyResult.getResult();
+ ExaremeAlgorithmResultDTO exaremeResult = JsonConverters.convertJsonStringToObject(
+ String.valueOf(results), ExaremeAlgorithmResultDTO.class
+ );
+ exaremeResult.setCode(code);
- return new ExperimentResult(code, resultDTOS);
+ return exaremeResult;
}
/**
@@ -585,7 +582,7 @@ public class ExperimentService {
* @param body is the parameters of the algorithm
* @return the result of exareme as well as the http status that was retrieved
*/
- public ExperimentResult runMIPEngineExperiment(String url, String body) {
+ public ExaremeAlgorithmResultDTO runMIPEngineExperiment(String url, String body) {
StringBuilder results = new StringBuilder();
int code;
@@ -596,9 +593,7 @@ public class ExperimentService {
}
System.out.println(results);
// Results are stored in the experiment object
- List<Object> resultDTOS = formattingMIPEngienResult(String.valueOf(results));
-
- return new ExperimentResult(code, resultDTOS);
+ return convertMIPEngineResultToExaremeAlgorithmResult(code, String.valueOf(results));
}
/* -------------------------------------- EXAREME CALLS ---------------------------------------------------------*/
@@ -628,12 +623,12 @@ public class ExperimentService {
try {
// Results are stored in the experiment object
- ExperimentResult experimentResult = runExperiment(finalExperimentDTO, logger);
+ ExaremeAlgorithmResultDTO exaremeAlgorithmResultDTO = runExperiment(finalExperimentDTO, logger);
- Logger.LogExperimentAction(experimentDAO.getName(), experimentDAO.getUuid(), "Experiment with uuid: " + experimentDAO.getUuid() + "gave response code: " + experimentResult.getCode() + " and result: " + experimentResult.getResults());
+ Logger.LogExperimentAction(experimentDAO.getName(), experimentDAO.getUuid(), "Experiment with uuid: " + experimentDAO.getUuid() + "gave response code: " + exaremeAlgorithmResultDTO.getCode() + " and result: " + exaremeAlgorithmResultDTO.getResults());
- experimentDAO.setResult((experimentResult.getCode() >= 400) ? null : JsonConverters.convertObjectToJsonString(experimentResult.getResults()));
- experimentDAO.setStatus((experimentResult.getCode() >= 400) ? ExperimentDAO.Status.error : ExperimentDAO.Status.success);
+ experimentDAO.setResult((exaremeAlgorithmResultDTO.getCode() >= 400) ? null : JsonConverters.convertObjectToJsonString(exaremeAlgorithmResultDTO.getResults()));
+ experimentDAO.setStatus((exaremeAlgorithmResultDTO.getCode() >= 400) ? ExperimentDAO.Status.error : ExperimentDAO.Status.success);
} catch (Exception e) {
Logger.LogExperimentAction(experimentDAO.getName(), experimentDAO.getUuid(), "There was an exception: " + e.getMessage());
@@ -667,13 +662,13 @@ public class ExperimentService {
String workflowId = experimentDTO.getAlgorithm().getName();
// Get the parameters
- List<AlgorithmDTO.AlgorithmParamDTO> algorithmParameters
+ List<ExaremeAlgorithmRequestDTO> algorithmParameters
= experimentDTO.getAlgorithm().getParameters();
// Convert the parameters to workflow parameters
HashMap<String, String> algorithmParamsIncludingEmpty = new HashMap<>();
if (algorithmParameters != null) {
- for (AlgorithmDTO.AlgorithmParamDTO param : algorithmParameters) {
+ for (ExaremeAlgorithmRequestDTO param : algorithmParameters) {
algorithmParamsIncludingEmpty.put(param.getName(), param.getValue());
}
}
@@ -1038,54 +1033,4 @@ public class ExperimentService {
return returnError;
}
-
- @Getter
- @Setter
- static class ExperimentResult {
- private final int code;
- private final List<Object> results;
-
- public ExperimentResult(int code, List<Object> results) {
- this.code = code;
- this.results = results;
- }
- }
-
- @Getter
- @Setter
- @AllArgsConstructor
- static class Visualization {
- private final String title;
- private final String profile;
- private final List<Field> columns;
- private final List<List<Object>> data;
- }
-
- @Getter
- @Setter
- @AllArgsConstructor
- static class MIPVisualization {
- private final String title;
- private final List<String> columns;
- private final List<List<Object>> data;
-
- public Visualization convertToVisualization() {
- ArrayList<Field> fields = new ArrayList<>();
- this.columns.forEach(header_name -> fields.add(new Field(header_name, "number")));
- return new Visualization(this.title, "tabular-data-resource", fields, this.data);
- }
-
- }
-
- @Getter
- @Setter
- static class Field {
- private final String name;
- private final String type;
-
- Field(String name, String type) {
- this.name = name;
- this.type = type;
- }
- }
}