From c19f6a9ad87c9dd384fb9bb244575181f9d0b263 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 16 Jul 2024 10:05:26 +0200
Subject: [PATCH 01/99] core: first nextflow implementation, #TASK-6445

---
 .../analysis/tools/NextFlowExecutor.java      | 300 ++++++++++++++++++
 .../opencga/analysis/tools/OpenCgaTool.java   |   5 +
 .../src/main/resources/nextflow.config        |   6 +
 .../analysis/tools/NextFlowExecutorTest.java  |  32 ++
 .../catalog/db/api/NextFlowDBAdaptor.java     |  68 ++++
 .../db/mongodb/NextFlowMongoDBAdaptor.java    | 259 +++++++++++++++
 .../mongodb/converters/NextFlowConverter.java |  10 +
 .../NextFlowCatalogMongoDBIterator.java       |  47 +++
 opencga-client/src/main/R/R/Admin-methods.R   |   2 +-
 opencga-client/src/main/R/R/Study-methods.R   |   2 +-
 opencga-client/src/main/javascript/Admin.js   |   2 +-
 opencga-client/src/main/javascript/Study.js   |   2 +-
 .../pyopencga/rest_clients/admin_client.py    |   3 +-
 .../pyopencga/rest_clients/study_client.py    |   2 +-
 .../opencga/core/models/common/Enums.java     |   1 +
 .../core/models/nextflow/NextFlow.java        |  54 ++++
 .../models/nextflow/NextFlowRunParams.java    |  46 +++
 .../tools/result/ExecutionResultManager.java  |   4 +
 18 files changed, 839 insertions(+), 6 deletions(-)
 create mode 100644 opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
 create mode 100644 opencga-analysis/src/main/resources/nextflow.config
 create mode 100644 opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/NextFlowExecutorTest.java
 create mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/NextFlowDBAdaptor.java
 create mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/NextFlowMongoDBAdaptor.java
 create mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/NextFlowConverter.java
 create mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/NextFlowCatalogMongoDBIterator.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlow.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlowRunParams.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
new file mode 100644
index 00000000000..c3398c82c3a
--- /dev/null
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
@@ -0,0 +1,300 @@
+package org.opencb.opencga.analysis.tools;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.lang3.time.StopWatch;
+import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.commons.utils.DockerUtils;
+import org.opencb.opencga.core.common.JacksonUtils;
+import org.opencb.opencga.core.common.TimeUtils;
+import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.nextflow.NextFlowRunParams;
+import org.opencb.opencga.core.tools.annotations.Tool;
+import org.opencb.opencga.core.tools.annotations.ToolParams;
+import org.opencb.opencga.core.tools.result.Status;
+import org.opencb.opencga.core.tools.result.ToolStep;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.UncheckedIOException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.stream.Stream;
+
+import static org.opencb.opencga.analysis.wrappers.executors.DockerWrapperAnalysisExecutor.DOCKER_INPUT_PATH;
+import static org.opencb.opencga.analysis.wrappers.executors.DockerWrapperAnalysisExecutor.DOCKER_OUTPUT_PATH;
+
+@Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.NEXTFLOW, description = NextFlowExecutor.DESCRIPTION)
+public class NextFlowExecutor extends OpenCgaTool {
+
+    public final static String ID = "nextflow-run";
+    public static final String DESCRIPTION = "Execute a Nextflow analysis.";
+
+    public final static String DOCKER_IMAGE = "nextflow/nextflow";
+
+    @ToolParams
+    protected NextFlowRunParams toolParams = new NextFlowRunParams();
+
+    private String script;
+
+    private final static Logger logger = LoggerFactory.getLogger(NextFlowExecutor.class);
+
+    @Override
+    protected void check() throws Exception {
+        super.check();
+
+        if (toolParams.getId() == null) {
+            throw new IllegalArgumentException("Missing Nextflow ID");
+        }
+
+        // TODO: Change and look for Nextflow script
+        this.script = "params.str = 'Hello world!'\n" +
+                "\n" +
+                "process splitLetters {\n" +
+                "    output:\n" +
+                "    path 'chunk_*'\n" +
+                "\n" +
+                "    \"\"\"\n" +
+                "    printf '${params.str}' | split -b 6 - chunk_\n" +
+                "    \"\"\"\n" +
+                "}\n" +
+                "\n" +
+                "process convertToUpper {\n" +
+                "    input:\n" +
+                "    path x\n" +
+                "\n" +
+                "    output:\n" +
+                "    stdout\n" +
+                "\n" +
+                "    \"\"\"\n" +
+                "    cat $x | tr '[a-z]' '[A-Z]'\n" +
+                "    \"\"\"\n" +
+                "}\n" +
+                "\n" +
+                "process sleep {\n" +
+                "    input:\n" +
+                "    val x\n" +
+                "\n" +
+                "    \"\"\"\n" +
+                "    sleep 1\n" +
+                "    \"\"\"\n" +
+                "}\n" +
+                "\n" +
+                "workflow {\n" +
+                "    splitLetters | flatten | convertToUpper | view { it.trim() } | sleep\n" +
+                "}";
+    }
+
+    @Override
+    protected void run() throws Exception {
+        // Write main script file
+        Files.write(getOutDir().resolve("pipeline.nf"), script.getBytes());
+
+        // Write nextflow.config file
+        URL nextflowConfig = getClass().getResource("/nextflow.config");
+        if (nextflowConfig != null) {
+            Files.copy(nextflowConfig.openStream(), getOutDir().resolve("nextflow.config"));
+        } else {
+            throw new RuntimeException("Can't fetch nextflow.config file");
+        }
+
+        // Execute docker image
+        String workingDirectory = getOutDir().toAbsolutePath().toString();
+        List<AbstractMap.SimpleEntry<String, String>> inputBindings = new ArrayList<>();
+        inputBindings.add(new AbstractMap.SimpleEntry<>(workingDirectory, DOCKER_INPUT_PATH));
+        AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(workingDirectory, DOCKER_OUTPUT_PATH);
+
+        // TODO: Copy nextflow.config and pipeline.nf to DOCKER_INPUT_PATH
+
+        StringBuilder stringBuilder = new StringBuilder()
+                .append("nextflow run ").append(DOCKER_OUTPUT_PATH).append("/pipeline.nf")
+                .append(" --work-dir ").append(DOCKER_OUTPUT_PATH)
+                .append(" -with-report ").append(DOCKER_OUTPUT_PATH).append("/report.html");
+
+        StopWatch stopWatch = StopWatch.createStarted();
+        Map<String, String> dockerParams = new HashMap<>();
+        dockerParams.put("user", "root");
+        String cmdline = DockerUtils.run(DOCKER_IMAGE, inputBindings, outputBinding, stringBuilder.toString(), dockerParams);
+        logger.info("Docker command line: " + cmdline);
+        logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
+
+        // Delete input files
+        Files.delete(getOutDir().resolve("pipeline.nf"));
+        Files.delete(getOutDir().resolve("nextflow.config"));
+
+        processTraceFile();
+    }
+
+    private void processTraceFile() {
+        List<ToolStep> steps = new LinkedList<>();
+        // Read tabular file
+        Path traceFile = getOutDir().resolve("trace.txt");
+        if (Files.exists(traceFile)) {
+            try (Stream<String> lines = Files.lines(traceFile)) {
+                // Read line one by one
+                lines.forEach(line -> {
+                    if (line.startsWith("task_id")) {
+                        return;
+                    }
+                    Trace trace = new Trace(line);
+                    ToolStep toolStep = trace.toToolStep();
+                    steps.add(toolStep);
+                    System.out.println(trace);
+                });
+            } catch (Exception e) {
+                logger.error("Error reading trace file: " + traceFile, e);
+            }
+        }
+
+        try {
+            setManualSteps(steps);
+        } catch (ToolException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static class Trace {
+        private String taskId;
+        private String hash;
+        private String name;
+        private String status;
+        private String start;
+        private String complete;
+        private String cpu;
+        private String peak_vmem;
+
+        public Trace() {
+        }
+
+        public Trace(String traceLine) {
+            String[] split = traceLine.split("\t");
+            this.taskId = split[0];
+            this.hash = split[1];
+            this.name = split[2];
+            this.status = split[3];
+            this.start = split[4];
+            this.complete = split[5];
+            this.cpu = split[6];
+            this.peak_vmem = split[7];
+        }
+
+        public Trace(String taskId, String hash, String name, String status, String start, String complete, String cpu, String peak_vmem) {
+            this.taskId = taskId;
+            this.hash = hash;
+            this.name = name;
+            this.status = status;
+            this.start = start;
+            this.complete = complete;
+            this.cpu = cpu;
+            this.peak_vmem = peak_vmem;
+        }
+
+        public ToolStep toToolStep() {
+            Date startDate = toDate(start);
+            Date completeDate = toDate(complete);
+            return new ToolStep(taskId, startDate, completeDate,
+                    status.equals("COMPLETED") ? Status.Type.DONE : Status.Type.ERROR, toObjectMap());
+        }
+
+        public String getTaskId() {
+            return taskId;
+        }
+
+        public Trace setTaskId(String taskId) {
+            this.taskId = taskId;
+            return this;
+        }
+
+        public String getHash() {
+            return hash;
+        }
+
+        public Trace setHash(String hash) {
+            this.hash = hash;
+            return this;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public Trace setName(String name) {
+            this.name = name;
+            return this;
+        }
+
+        public String getStatus() {
+            return status;
+        }
+
+        public Trace setStatus(String status) {
+            this.status = status;
+            return this;
+        }
+
+        public String getStart() {
+            return start;
+        }
+
+        public Trace setStart(String start) {
+            this.start = start;
+            return this;
+        }
+
+        public String getComplete() {
+            return complete;
+        }
+
+        public Trace setComplete(String complete) {
+            this.complete = complete;
+            return this;
+        }
+
+        public String getCpu() {
+            return cpu;
+        }
+
+        public Trace setCpu(String cpu) {
+            this.cpu = cpu;
+            return this;
+        }
+
+        public String getPeak_vmem() {
+            return peak_vmem;
+        }
+
+        public Trace setPeak_vmem(String peak_vmem) {
+            this.peak_vmem = peak_vmem;
+            return this;
+        }
+
+        public ObjectMap toObjectMap() {
+            ObjectMapper objectMapper = JacksonUtils.getDefaultObjectMapper();
+            try {
+                return new ObjectMap(objectMapper.writeValueAsString(this));
+            } catch (JsonProcessingException e) {
+                throw new UncheckedIOException(e);
+            }
+        }
+
+    }
+
+    static Date toDate(String dateStr) {
+        String format = "yyyy-MM-dd HH:mm:ss.SSS";
+        SimpleDateFormat sdf = new SimpleDateFormat(format);
+
+        Date date = null;
+        try {
+            date = sdf.parse(dateStr);
+        } catch (ParseException e) {
+            logger.warn(e.getMessage());
+        }
+        return date;
+    }
+
+}
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
index 5a88635e45c..75720aee064 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
@@ -43,6 +43,7 @@
 import org.opencb.opencga.core.tools.result.ExecutionResult;
 import org.opencb.opencga.core.tools.result.ExecutionResultManager;
 import org.opencb.opencga.core.tools.result.ExecutorInfo;
+import org.opencb.opencga.core.tools.result.ToolStep;
 import org.opencb.opencga.storage.core.StorageEngineFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -482,6 +483,10 @@ protected final void step(String stepId, StepRunnable step) throws ToolException
         }
     }
 
+    protected final void setManualSteps(List<ToolStep> steps) throws ToolException {
+        erm.setManualSteps(steps);
+    }
+
     protected final boolean checkStep(String stepId) throws ToolException {
         return erm.checkStep(stepId);
     }
diff --git a/opencga-analysis/src/main/resources/nextflow.config b/opencga-analysis/src/main/resources/nextflow.config
new file mode 100644
index 00000000000..fd91b7d3811
--- /dev/null
+++ b/opencga-analysis/src/main/resources/nextflow.config
@@ -0,0 +1,6 @@
+trace {
+    enabled = true
+    file = '/data/output/trace.txt'
+    overwrite = true
+    fields = 'task_id,hash,name,status,start,complete,%cpu,peak_vmem'
+}
\ No newline at end of file
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/NextFlowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/NextFlowExecutorTest.java
new file mode 100644
index 00000000000..bcc66443b93
--- /dev/null
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/NextFlowExecutorTest.java
@@ -0,0 +1,32 @@
+package org.opencb.opencga.analysis.tools;
+
+import org.apache.commons.lang3.time.StopWatch;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.opencb.opencga.analysis.variant.OpenCGATestExternalResource;
+import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.nextflow.NextFlowRunParams;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.concurrent.TimeUnit;
+
+public class NextFlowExecutorTest {
+
+    @ClassRule
+    public static OpenCGATestExternalResource opencga = new OpenCGATestExternalResource(false);
+
+    @Test
+    public void myTest() throws ToolException, IOException {
+        Path outDir = Paths.get(opencga.createTmpOutdir("_nextflow"));
+
+        StopWatch stopWatch = StopWatch.createStarted();
+        NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
+        NextFlowRunParams runParams = new NextFlowRunParams("myId", 2);
+        nextFlowExecutorTest.setUp(opencga.getOpencgaHome().toString(), runParams.toObjectMap(), outDir, opencga.getAdminToken());
+        nextFlowExecutorTest.start();
+        System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
+    }
+
+}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/NextFlowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/NextFlowDBAdaptor.java
new file mode 100644
index 00000000000..d3ee6a73bfc
--- /dev/null
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/NextFlowDBAdaptor.java
@@ -0,0 +1,68 @@
+package org.opencb.opencga.catalog.db.api;
+
+import org.apache.commons.collections4.map.LinkedMap;
+import org.opencb.commons.datastore.core.QueryParam;
+import org.opencb.opencga.core.models.nextflow.NextFlow;
+
+import java.util.Map;
+
+import static org.opencb.commons.datastore.core.QueryParam.Type.*;
+
+public interface NextFlowDBAdaptor extends CoreDBAdaptor<NextFlow> {
+
+    enum QueryParams implements QueryParam {
+        ID("id", TEXT, ""),
+        UID("uid", LONG, ""),
+        UUID("uuid", TEXT, ""),
+        RELEASE("release", INTEGER, ""), //  Release where the sample was created
+        SNAPSHOT("snapshot", INTEGER, ""), // Last version of sample at release = snapshot
+        VERSION("version", INTEGER, ""), // Version of the sample
+        CREATION_DATE("creationDate", DATE, ""),
+        MODIFICATION_DATE("modificationDate", DATE, ""),
+        STUDY_UID("studyUid", INTEGER_ARRAY, ""),
+        STUDY("study", INTEGER_ARRAY, ""); // Alias to studyId in the database. Only for the webservices.
+
+        private static Map<String, QueryParams> map;
+
+        static {
+            map = new LinkedMap();
+            for (QueryParams params : QueryParams.values()) {
+                map.put(params.key(), params);
+            }
+        }
+
+        private final String key;
+        private Type type;
+        private String description;
+
+        QueryParams(String key, Type type, String description) {
+            this.key = key;
+            this.type = type;
+            this.description = description;
+        }
+
+        public static Map<String, QueryParams> getMap() {
+            return map;
+        }
+
+        public static QueryParams getParam(String key) {
+            return map.get(key);
+        }
+
+        @Override
+        public String key() {
+            return key;
+        }
+
+        @Override
+        public Type type() {
+            return type;
+        }
+
+        @Override
+        public String description() {
+            return description;
+        }
+    }
+
+}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/NextFlowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/NextFlowMongoDBAdaptor.java
new file mode 100644
index 00000000000..401f0f28872
--- /dev/null
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/NextFlowMongoDBAdaptor.java
@@ -0,0 +1,259 @@
+package org.opencb.opencga.catalog.db.mongodb;
+
+import com.mongodb.client.ClientSession;
+import org.apache.commons.lang3.time.StopWatch;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.commons.datastore.core.Query;
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.commons.datastore.mongodb.MongoDBCollection;
+import org.opencb.commons.datastore.mongodb.MongoDBIterator;
+import org.opencb.opencga.catalog.db.api.DBIterator;
+import org.opencb.opencga.catalog.db.api.NextFlowDBAdaptor;
+import org.opencb.opencga.catalog.db.mongodb.converters.NextFlowConverter;
+import org.opencb.opencga.catalog.db.mongodb.iterators.NextFlowCatalogMongoDBIterator;
+import org.opencb.opencga.catalog.exceptions.CatalogAuthorizationException;
+import org.opencb.opencga.catalog.exceptions.CatalogDBException;
+import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
+import org.opencb.opencga.core.config.Configuration;
+import org.opencb.opencga.core.models.nextflow.NextFlow;
+import org.opencb.opencga.core.response.OpenCGAResult;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+import static org.opencb.opencga.catalog.db.mongodb.MongoDBUtils.fixAclProjection;
+
+public class NextFlowMongoDBAdaptor extends CatalogMongoDBAdaptor implements NextFlowDBAdaptor {
+
+    private final MongoDBCollection nextflowCollection;
+    private final MongoDBCollection archiveNextflowCollection;
+    private final MongoDBCollection deleteNextflowCollection;
+    private final SnapshotVersionedMongoDBAdaptor versionedMongoDBAdaptor;
+    private final NextFlowConverter nextflowConverter;
+
+    public NextFlowMongoDBAdaptor(MongoDBCollection nextflowCollection, MongoDBCollection archiveNextflowCollection,
+                                  MongoDBCollection deleteNextflowCollection, Configuration configuration,
+                                  OrganizationMongoDBAdaptorFactory dbAdaptorFactory) {
+        super(configuration, LoggerFactory.getLogger(NextFlowMongoDBAdaptor.class));
+        this.dbAdaptorFactory = dbAdaptorFactory;
+        this.nextflowCollection = nextflowCollection;
+        this.archiveNextflowCollection = archiveNextflowCollection;
+        this.deleteNextflowCollection = deleteNextflowCollection;
+        this.versionedMongoDBAdaptor = new SnapshotVersionedMongoDBAdaptor(nextflowCollection, archiveNextflowCollection,
+                deleteNextflowCollection);
+        this.nextflowConverter = new NextFlowConverter();
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> get(long studyUid, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        long startTime = startQuery();
+        try (DBIterator<NextFlow> dbIterator = iterator(studyUid, query, options, user)) {
+            return endQuery(startTime, dbIterator);
+        }
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> get(Query query, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        long startTime = startQuery();
+        try (DBIterator<NextFlow> dbIterator = iterator(query, options)) {
+            return endQuery(startTime, dbIterator);
+        }
+    }
+
+    @Override
+    public OpenCGAResult nativeGet(long studyUid, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        long startTime = startQuery();
+        try (DBIterator<Document> dbIterator = nativeIterator(studyUid, query, options, user)) {
+            return endQuery(startTime, dbIterator);
+        }
+    }
+
+    @Override
+    OpenCGAResult<Document> nativeGet(Query query, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        long startTime = startQuery();
+        try (DBIterator<Document> dbIterator = nativeIterator(query, options)) {
+            return endQuery(startTime, dbIterator);
+        }
+    }
+
+    @Override
+    public DBIterator<NextFlow> iterator(long studyUid, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        query.put(PRIVATE_STUDY_UID, studyUid);
+        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, options, user);
+        return new NextFlowCatalogMongoDBIterator<>(mongoCursor, null, nextflowConverter, null, studyUid, user, options);
+    }
+
+    @Override
+    public DBIterator<NextFlow> iterator(Query query, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, options, null);
+        return new NextFlowCatalogMongoDBIterator<>(mongoCursor, null, nextflowConverter, null, options);
+    }
+
+    @Override
+    public DBIterator nativeIterator(Query query, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        QueryOptions queryOptions = options != null ? new QueryOptions(options) : new QueryOptions();
+        queryOptions.put(NATIVE_QUERY, true);
+        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, queryOptions, null);
+        return new NextFlowCatalogMongoDBIterator(mongoCursor, null, null, null, options);
+    }
+
+    @Override
+    public DBIterator nativeIterator(long studyUid, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        QueryOptions queryOptions = options != null ? new QueryOptions(options) : new QueryOptions();
+        queryOptions.put(NATIVE_QUERY, true);
+
+        query.put(PRIVATE_STUDY_UID, studyUid);
+        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, queryOptions, user);
+        return new NextFlowCatalogMongoDBIterator<>(mongoCursor, null, null, null, studyUid, user, options);
+    }
+
+    @Override
+    public OpenCGAResult<Long> count(Query query, String user)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Bson bson = parseQuery(query, user);
+        return new OpenCGAResult<>(nextflowCollection.count(null, bson));
+    }
+
+    @Override
+    public OpenCGAResult<Long> count(Query query)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Bson bson = parseQuery(query);
+        return new OpenCGAResult<>(nextflowCollection.count(null, bson));
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> groupBy(Query query, List<String> fields, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> groupBy(Query query, String field, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Bson bsonQuery = parseQuery(query);
+        return groupBy(nextflowCollection, bsonQuery, field, NextFlowDBAdaptor.QueryParams.ID.key(), options);
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> groupBy(Query query, List<String> fields, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Bson bsonQuery = parseQuery(query);
+        return groupBy(nextflowCollection, bsonQuery, fields, NextFlowDBAdaptor.QueryParams.ID.key(), options);
+    }
+
+    @Override
+    public OpenCGAResult<?> distinct(long studyUid, String field, Query query, String userId)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Query finalQuery = query != null ? new Query(query) : new Query();
+        finalQuery.put(NextFlowDBAdaptor.QueryParams.STUDY_UID.key(), studyUid);
+        Bson bson = parseQuery(finalQuery, userId);
+        return new OpenCGAResult<>(nextflowCollection.distinct(field, bson));
+    }
+
+    @Override
+    public OpenCGAResult<?> distinct(long studyUid, List<String> fields, Query query, String userId)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        StopWatch stopWatch = StopWatch.createStarted();
+        Query finalQuery = query != null ? new Query(query) : new Query();
+        finalQuery.put(NextFlowDBAdaptor.QueryParams.STUDY_UID.key(), studyUid);
+        Bson bson = parseQuery(finalQuery, userId);
+
+        Set<String> results = new LinkedHashSet<>();
+        for (String field : fields) {
+            results.addAll(nextflowCollection.distinct(field, bson, String.class).getResults());
+        }
+
+        return new OpenCGAResult<>((int) stopWatch.getTime(TimeUnit.MILLISECONDS), Collections.emptyList(), results.size(),
+                new ArrayList<>(results), -1);
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> stats(Query query) {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> update(long id, ObjectMap parameters, QueryOptions queryOptions)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> update(Query query, ObjectMap parameters, QueryOptions queryOptions)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> delete(NextFlow id) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> delete(Query query) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> restore(long id, QueryOptions queryOptions) throws CatalogDBException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> restore(Query query, QueryOptions queryOptions) throws CatalogDBException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<NextFlow> rank(Query query, String field, int numResults, boolean asc)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public void forEach(Query query, Consumer<? super Object> action, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+
+    }
+
+
+    private MongoDBIterator<Document> getMongoCursor(ClientSession clientSession, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Query finalQuery = new Query(query);
+
+        QueryOptions qOptions;
+        if (options != null) {
+            qOptions = new QueryOptions(options);
+        } else {
+            qOptions = new QueryOptions();
+        }
+        fixAclProjection(qOptions);
+
+        Bson bson = parseQuery(finalQuery, user);
+        MongoDBCollection collection = getQueryCollection(finalQuery, nextflowCollection, archiveNextflowCollection,
+                deleteNextflowCollection);
+        logger.debug("Nextflow query: {}", bson.toBsonDocument());
+        return collection.iterator(clientSession, bson, null, null, qOptions);
+    }
+
+
+    private Bson parseQuery(Query query) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return parseQuery(query, null);
+    }
+
+    private Bson parseQuery(Query query, String user) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/NextFlowConverter.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/NextFlowConverter.java
new file mode 100644
index 00000000000..6abbee7e1fd
--- /dev/null
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/NextFlowConverter.java
@@ -0,0 +1,10 @@
+package org.opencb.opencga.catalog.db.mongodb.converters;
+
+import org.opencb.opencga.core.models.nextflow.NextFlow;
+
+public class NextFlowConverter extends OpenCgaMongoConverter<NextFlow> {
+
+    public NextFlowConverter() {
+        super(NextFlow.class);
+    }
+}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/NextFlowCatalogMongoDBIterator.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/NextFlowCatalogMongoDBIterator.java
new file mode 100644
index 00000000000..05e279f4965
--- /dev/null
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/NextFlowCatalogMongoDBIterator.java
@@ -0,0 +1,47 @@
+package org.opencb.opencga.catalog.db.mongodb.iterators;
+
+import com.mongodb.client.ClientSession;
+import org.bson.Document;
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.commons.datastore.mongodb.GenericDocumentComplexConverter;
+import org.opencb.commons.datastore.mongodb.MongoDBIterator;
+import org.opencb.opencga.catalog.db.mongodb.OrganizationMongoDBAdaptorFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class NextFlowCatalogMongoDBIterator<E> extends CatalogMongoDBIterator<E> {
+
+    private long studyUid;
+    private String user;
+
+    private QueryOptions options;
+    private Queue<Document> nextflowListBuffer;
+
+    private Logger logger;
+
+    private static final int BUFFER_SIZE = 100;
+    private static final String UID_VERSION_SEP = "___";
+
+    public NextFlowCatalogMongoDBIterator(MongoDBIterator<Document> mongoCursor, ClientSession clientSession,
+                                                GenericDocumentComplexConverter<E> converter,
+                                                OrganizationMongoDBAdaptorFactory dbAdaptorFactory, QueryOptions options) {
+        this(mongoCursor, clientSession, converter, dbAdaptorFactory, 0, null, options);
+    }
+
+    public NextFlowCatalogMongoDBIterator(MongoDBIterator<Document> mongoCursor, ClientSession clientSession,
+                                          GenericDocumentComplexConverter<E> converter, OrganizationMongoDBAdaptorFactory dbAdaptorFactory,
+                                          long studyUid, String user, QueryOptions options) {
+        super(mongoCursor, clientSession, converter, null);
+
+        this.user = user;
+        this.studyUid = studyUid;
+
+        this.options = options;
+        this.nextflowListBuffer = new LinkedList<>();
+        this.logger = LoggerFactory.getLogger(NextFlowCatalogMongoDBIterator.class);
+    }
+
+}
diff --git a/opencga-client/src/main/R/R/Admin-methods.R b/opencga-client/src/main/R/R/Admin-methods.R
index d63a1ad3478..5bfb1b049c2 100644
--- a/opencga-client/src/main/R/R/Admin-methods.R
+++ b/opencga-client/src/main/R/R/Admin-methods.R
@@ -43,7 +43,7 @@ setMethod("adminClient", "OpencgaR", function(OpencgaR, user, endpointName, para
         #' @param count Count the number of elements matching the group.
         #' @param limit Maximum number of documents (groups) to be returned.
         #' @param fields Comma separated list of fields by which to group by.
-        #' @param entity Entity to be grouped by. Allowed values: ['AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA FUNCTIONAL']
+        #' @param entity Entity to be grouped by. Allowed values: ['AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL']
         #' @param action Action performed.
         #' @param before Object before update.
         #' @param after Object after update.
diff --git a/opencga-client/src/main/R/R/Study-methods.R b/opencga-client/src/main/R/R/Study-methods.R
index ddbc75ca374..ba022ea666e 100644
--- a/opencga-client/src/main/R/R/Study-methods.R
+++ b/opencga-client/src/main/R/R/Study-methods.R
@@ -118,7 +118,7 @@ setMethod("studyClient", "OpencgaR", function(OpencgaR, group, id, members, stud
         #' @param operationId Audit operation UUID.
         #' @param userId User ID.
         #' @param action Action performed by the user.
-        #' @param resource Resource involved. Allowed values: ['AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA FUNCTIONAL']
+        #' @param resource Resource involved. Allowed values: ['AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL']
         #' @param resourceId Resource ID.
         #' @param resourceUuid resource UUID.
         #' @param status Filter by status. Allowed values: ['SUCCESS ERROR']
diff --git a/opencga-client/src/main/javascript/Admin.js b/opencga-client/src/main/javascript/Admin.js
index 3f6204d4165..5538e904dfc 100644
--- a/opencga-client/src/main/javascript/Admin.js
+++ b/opencga-client/src/main/javascript/Admin.js
@@ -37,7 +37,7 @@ export default class Admin extends OpenCGAParentClass {
     /** Group by operation
     * @param {String} fields - Comma separated list of fields by which to group by.
     * @param {"AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS
-    *     INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA FUNCTIONAL"} entity - Entity to be grouped by.
+    *     INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL"} entity - Entity to be grouped by.
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {Boolean} [params.count] - Count the number of elements matching the group.
     * @param {Number} [params.limit = "50"] - Maximum number of documents (groups) to be returned. The default value is 50.
diff --git a/opencga-client/src/main/javascript/Study.js b/opencga-client/src/main/javascript/Study.js
index 9e013fef0dc..2c2b6abf793 100644
--- a/opencga-client/src/main/javascript/Study.js
+++ b/opencga-client/src/main/javascript/Study.js
@@ -119,7 +119,7 @@ export default class Study extends OpenCGAParentClass {
     * @param {String} [params.userId] - User ID.
     * @param {String} [params.action] - Action performed by the user.
     * @param {"AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS
-    *     INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA FUNCTIONAL"} [params.resource] - Resource involved.
+    *     INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL"} [params.resource] - Resource involved.
     * @param {String} [params.resourceId] - Resource ID.
     * @param {String} [params.resourceUuid] - resource UUID.
     * @param {"SUCCESS ERROR"} [params.status] - Filter by status.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/admin_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/admin_client.py
index 7311fa7e5dd..9702e5d6463 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/admin_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/admin_client.py
@@ -27,7 +27,8 @@ def group_by_audit(self, fields, entity, **options):
         :param str entity: Entity to be grouped by. Allowed values: ['AUDIT
             NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL
             COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION
-            VARIANT ALIGNMENT CLINICAL EXPRESSION RGA FUNCTIONAL'] (REQUIRED)
+            VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL']
+            (REQUIRED)
         :param str fields: Comma separated list of fields by which to group
             by. (REQUIRED)
         :param bool count: Count the number of elements matching the group.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/study_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/study_client.py
index 93e70823d52..639f20c6b53 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/study_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/study_client.py
@@ -139,7 +139,7 @@ def search_audit(self, study, **options):
         :param str resource: Resource involved. Allowed values: ['AUDIT NOTE
             ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT
             DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT
-            ALIGNMENT CLINICAL EXPRESSION RGA FUNCTIONAL']
+            ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL']
         :param str resource_id: Resource ID.
         :param str resource_uuid: resource UUID.
         :param str status: Filter by status. Allowed values: ['SUCCESS ERROR']
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/common/Enums.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/common/Enums.java
index 2777222715b..04981030ebc 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/common/Enums.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/common/Enums.java
@@ -79,6 +79,7 @@ public enum Resource {
         CLINICAL,
         EXPRESSION,
         RGA,
+        NEXTFLOW,
         FUNCTIONAL;
 
         public List<String> getFullPermissionList() {
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlow.java
new file mode 100644
index 00000000000..af4a527ef1d
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlow.java
@@ -0,0 +1,54 @@
+package org.opencb.opencga.core.models.nextflow;
+
+public class NextFlow {
+
+    private String id;
+    private int version;
+    private String script;
+
+    public NextFlow() {
+    }
+
+    public NextFlow(String id, int version, String script) {
+        this.id = id;
+        this.version = version;
+        this.script = script;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("NextFlow{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", version=").append(version);
+        sb.append(", script='").append(script).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public NextFlow setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public int getVersion() {
+        return version;
+    }
+
+    public NextFlow setVersion(int version) {
+        this.version = version;
+        return this;
+    }
+
+    public String getScript() {
+        return script;
+    }
+
+    public NextFlow setScript(String script) {
+        this.script = script;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlowRunParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlowRunParams.java
new file mode 100644
index 00000000000..062863b3916
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlowRunParams.java
@@ -0,0 +1,46 @@
+package org.opencb.opencga.core.models.nextflow;
+
+import org.opencb.opencga.core.tools.ToolParams;
+
+public class NextFlowRunParams extends ToolParams {
+
+    public static final String DESCRIPTION = "NextFlow run parameters";
+
+    private String id;
+    private Integer version;
+
+    public NextFlowRunParams() {
+    }
+
+    public NextFlowRunParams(String id, Integer version) {
+        this.id = id;
+        this.version = version;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("NextFlowRunParams{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", version=").append(version);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public NextFlowRunParams setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public Integer getVersion() {
+        return version;
+    }
+
+    public NextFlowRunParams setVersion(Integer version) {
+        this.version = version;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
index b1e716bd41f..aa84dcd3631 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
@@ -254,6 +254,10 @@ public void addStepAttribute(String key, Object value) throws ToolException {
         });
     }
 
+    public void setManualSteps(List<ToolStep> steps) throws ToolException {
+        updateResult(result -> result.setSteps(steps));
+    }
+
     public void errorStep() throws ToolException {
         updateResult(result -> getStep(result, result.getStatus().getStep())
                 .setStatus(Status.Type.ERROR).setEnd(now()));

From 621bef21eb2b4482d3ca04545c0f2d8ac9ec7b0d Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 18 Jul 2024 14:30:10 +0200
Subject: [PATCH 02/99] catalog: implement workflow manager and dbadaptor,
 #TASK-6445

---
 .../analysis/tools/NextFlowExecutor.java      | 166 +++++---
 .../src/main/resources/nextflow.config        |   2 +-
 .../analysis/tools/NextFlowExecutorTest.java  |  32 --
 .../analysis/tools/WorkflowExecutorTest.java  |  86 ++++
 .../variant/OpenCGATestExternalResource.java  |  21 +-
 .../opencga/catalog/db/DBAdaptorFactory.java  |   2 +
 ...wDBAdaptor.java => WorkflowDBAdaptor.java} |  15 +-
 .../db/mongodb/MongoDBAdaptorFactory.java     |   5 +
 .../db/mongodb/NextFlowMongoDBAdaptor.java    | 259 ------------
 .../OrganizationMongoDBAdaptorFactory.java    |  19 +
 .../SnapshotVersionedMongoDBAdaptor.java      |   3 +
 .../db/mongodb/WorkflowMongoDBAdaptor.java    | 386 ++++++++++++++++++
 .../mongodb/converters/NextFlowConverter.java |  10 -
 .../mongodb/converters/WorkflowConverter.java |  10 +
 ...va => WorkflowCatalogMongoDBIterator.java} |  12 +-
 .../catalog/managers/AbstractManager.java     |  13 +-
 .../catalog/managers/CatalogManager.java      |   7 +
 .../catalog/managers/WorkflowManager.java     | 220 ++++++++++
 .../opencga/catalog/utils/UuidUtils.java      |   3 +-
 .../CatalogManagerExternalResource.java       |  21 +
 opencga-client/src/main/R/R/Admin-methods.R   |   2 +-
 opencga-client/src/main/R/R/Study-methods.R   |   2 +-
 opencga-client/src/main/javascript/Admin.js   |   2 +-
 opencga-client/src/main/javascript/Study.js   |   2 +-
 .../pyopencga/rest_clients/admin_client.py    |   2 +-
 .../pyopencga/rest_clients/study_client.py    |   2 +-
 .../opencga/core/models/common/Enums.java     |   2 +-
 .../core/models/nextflow/NextFlow.java        |  54 ---
 .../core/models/nextflow/Workflow.java        | 165 ++++++++
 29 files changed, 1062 insertions(+), 463 deletions(-)
 delete mode 100644 opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/NextFlowExecutorTest.java
 create mode 100644 opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
 rename opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/{NextFlowDBAdaptor.java => WorkflowDBAdaptor.java} (71%)
 delete mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/NextFlowMongoDBAdaptor.java
 create mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
 delete mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/NextFlowConverter.java
 create mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
 rename opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/{NextFlowCatalogMongoDBIterator.java => WorkflowCatalogMongoDBIterator.java} (75%)
 create mode 100644 opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
 delete mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlow.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/Workflow.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
index c3398c82c3a..667356af04e 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
@@ -2,14 +2,18 @@
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
 import org.opencb.commons.datastore.core.ObjectMap;
-import org.opencb.commons.utils.DockerUtils;
+import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.nextflow.NextFlowRunParams;
+import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
 import org.opencb.opencga.core.tools.result.Status;
@@ -17,30 +21,34 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
 import java.io.UncheckedIOException;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-import java.util.*;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.stream.Stream;
 
-import static org.opencb.opencga.analysis.wrappers.executors.DockerWrapperAnalysisExecutor.DOCKER_INPUT_PATH;
-import static org.opencb.opencga.analysis.wrappers.executors.DockerWrapperAnalysisExecutor.DOCKER_OUTPUT_PATH;
-
-@Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.NEXTFLOW, description = NextFlowExecutor.DESCRIPTION)
+@Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.WORKFLOW, description = NextFlowExecutor.DESCRIPTION)
 public class NextFlowExecutor extends OpenCgaTool {
 
     public final static String ID = "nextflow-run";
     public static final String DESCRIPTION = "Execute a Nextflow analysis.";
 
-    public final static String DOCKER_IMAGE = "nextflow/nextflow";
-
     @ToolParams
     protected NextFlowRunParams toolParams = new NextFlowRunParams();
 
-    private String script;
+    private Workflow workflow;
+
+    private Thread thread;
+    private final int monitorThreadPeriod = 5000;
 
     private final static Logger logger = LoggerFactory.getLogger(NextFlowExecutor.class);
 
@@ -52,48 +60,23 @@ protected void check() throws Exception {
             throw new IllegalArgumentException("Missing Nextflow ID");
         }
 
-        // TODO: Change and look for Nextflow script
-        this.script = "params.str = 'Hello world!'\n" +
-                "\n" +
-                "process splitLetters {\n" +
-                "    output:\n" +
-                "    path 'chunk_*'\n" +
-                "\n" +
-                "    \"\"\"\n" +
-                "    printf '${params.str}' | split -b 6 - chunk_\n" +
-                "    \"\"\"\n" +
-                "}\n" +
-                "\n" +
-                "process convertToUpper {\n" +
-                "    input:\n" +
-                "    path x\n" +
-                "\n" +
-                "    output:\n" +
-                "    stdout\n" +
-                "\n" +
-                "    \"\"\"\n" +
-                "    cat $x | tr '[a-z]' '[A-Z]'\n" +
-                "    \"\"\"\n" +
-                "}\n" +
-                "\n" +
-                "process sleep {\n" +
-                "    input:\n" +
-                "    val x\n" +
-                "\n" +
-                "    \"\"\"\n" +
-                "    sleep 1\n" +
-                "    \"\"\"\n" +
-                "}\n" +
-                "\n" +
-                "workflow {\n" +
-                "    splitLetters | flatten | convertToUpper | view { it.trim() } | sleep\n" +
-                "}";
+        OpenCGAResult<Workflow> result = catalogManager.getWorkflowManager().get(toolParams.getId(), QueryOptions.empty(), token);
+        if (result.getNumResults() == 0) {
+            throw new ToolException("Workflow '" + toolParams.getId() + "' not found");
+        }
+        workflow = result.first();
+
+        if (workflow == null) {
+            throw new ToolException("Workflow '" + toolParams.getId() + "' is null");
+        }
     }
 
     @Override
     protected void run() throws Exception {
-        // Write main script file
-        Files.write(getOutDir().resolve("pipeline.nf"), script.getBytes());
+        for (Workflow.Script script : workflow.getScripts()) {
+            // Write script files
+            Files.write(getOutDir().resolve(script.getId()), script.getContent().getBytes());
+        }
 
         // Write nextflow.config file
         URL nextflowConfig = getClass().getResource("/nextflow.config");
@@ -105,31 +88,81 @@ protected void run() throws Exception {
 
         // Execute docker image
         String workingDirectory = getOutDir().toAbsolutePath().toString();
-        List<AbstractMap.SimpleEntry<String, String>> inputBindings = new ArrayList<>();
-        inputBindings.add(new AbstractMap.SimpleEntry<>(workingDirectory, DOCKER_INPUT_PATH));
-        AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(workingDirectory, DOCKER_OUTPUT_PATH);
-
-        // TODO: Copy nextflow.config and pipeline.nf to DOCKER_INPUT_PATH
 
         StringBuilder stringBuilder = new StringBuilder()
-                .append("nextflow run ").append(DOCKER_OUTPUT_PATH).append("/pipeline.nf")
-                .append(" --work-dir ").append(DOCKER_OUTPUT_PATH)
-                .append(" -with-report ").append(DOCKER_OUTPUT_PATH).append("/report.html");
+                .append("nextflow -c ").append(workingDirectory).append("/nextflow.config")
+                .append(" ").append(workflow.getCommandLine())
+//                .append(" run nextflow-io/rnaseq-nf -with-docker")
+//                .append(" run ").append(workingDirectory).append("/pipeline.nf")
+                .append(" -with-report ").append(workingDirectory).append("/report.html");
+        List<String> cliArgs = Arrays.asList(StringUtils.split(stringBuilder.toString(), " "));
+
+        startTraceFileMonitor();
 
         StopWatch stopWatch = StopWatch.createStarted();
-        Map<String, String> dockerParams = new HashMap<>();
-        dockerParams.put("user", "root");
-        String cmdline = DockerUtils.run(DOCKER_IMAGE, inputBindings, outputBinding, stringBuilder.toString(), dockerParams);
-        logger.info("Docker command line: " + cmdline);
+
+        // Execute nextflow binary
+        ProcessBuilder processBuilder = new ProcessBuilder(cliArgs);
+        // Establish the working directory of the process
+        processBuilder.directory(getOutDir().toFile());
+        logger.info("Executing: {}", stringBuilder);
+        Process p;
+        try {
+            p = processBuilder.start();
+            BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
+            BufferedReader error = new BufferedReader(new InputStreamReader(p.getErrorStream()));
+            String line;
+            while ((line = input.readLine()) != null) {
+                logger.info("{}", line);
+            }
+            while ((line = error.readLine()) != null) {
+                logger.error("{} ", line);
+            }
+            p.waitFor();
+            input.close();
+        } catch (IOException | InterruptedException e) {
+            throw new RuntimeException("Error executing cli: " + e.getMessage(), e);
+        }
+
         logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
 
         // Delete input files
-        Files.delete(getOutDir().resolve("pipeline.nf"));
+        for (Workflow.Script script : workflow.getScripts()) {
+            Files.delete(getOutDir().resolve(script.getId()));
+        }
         Files.delete(getOutDir().resolve("nextflow.config"));
 
+        endTraceFileMonitor();
+    }
+
+    @Override
+    protected void onShutdown() {
+        super.onShutdown();
+        endTraceFileMonitor();
+    }
+
+    protected void endTraceFileMonitor() {
+        if (thread != null) {
+            thread.interrupt();
+        }
         processTraceFile();
     }
 
+    private void startTraceFileMonitor() {
+        thread = new Thread(() -> {
+            while (!Thread.currentThread().isInterrupted()) {
+                try {
+                    Thread.sleep(monitorThreadPeriod);
+                } catch (InterruptedException e) {
+                    return;
+                }
+
+                processTraceFile();
+            }
+        });
+        thread.start();
+    }
+
     private void processTraceFile() {
         List<ToolStep> steps = new LinkedList<>();
         // Read tabular file
@@ -144,17 +177,17 @@ private void processTraceFile() {
                     Trace trace = new Trace(line);
                     ToolStep toolStep = trace.toToolStep();
                     steps.add(toolStep);
-                    System.out.println(trace);
                 });
             } catch (Exception e) {
                 logger.error("Error reading trace file: " + traceFile, e);
             }
         }
-
-        try {
-            setManualSteps(steps);
-        } catch (ToolException e) {
-            throw new RuntimeException(e);
+        if (CollectionUtils.isNotEmpty(steps)) {
+            try {
+                setManualSteps(steps);
+            } catch (ToolException e) {
+                logger.error("Error writing nextflow steps to ExecutionResult", e);
+            }
         }
     }
 
@@ -281,7 +314,6 @@ public ObjectMap toObjectMap() {
                 throw new UncheckedIOException(e);
             }
         }
-
     }
 
     static Date toDate(String dateStr) {
diff --git a/opencga-analysis/src/main/resources/nextflow.config b/opencga-analysis/src/main/resources/nextflow.config
index fd91b7d3811..aa0b82ae0ee 100644
--- a/opencga-analysis/src/main/resources/nextflow.config
+++ b/opencga-analysis/src/main/resources/nextflow.config
@@ -1,6 +1,6 @@
 trace {
     enabled = true
-    file = '/data/output/trace.txt'
+    file = 'trace.txt'
     overwrite = true
     fields = 'task_id,hash,name,status,start,complete,%cpu,peak_vmem'
 }
\ No newline at end of file
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/NextFlowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/NextFlowExecutorTest.java
deleted file mode 100644
index bcc66443b93..00000000000
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/NextFlowExecutorTest.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.opencb.opencga.analysis.tools;
-
-import org.apache.commons.lang3.time.StopWatch;
-import org.junit.ClassRule;
-import org.junit.Test;
-import org.opencb.opencga.analysis.variant.OpenCGATestExternalResource;
-import org.opencb.opencga.core.exceptions.ToolException;
-import org.opencb.opencga.core.models.nextflow.NextFlowRunParams;
-
-import java.io.IOException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.concurrent.TimeUnit;
-
-public class NextFlowExecutorTest {
-
-    @ClassRule
-    public static OpenCGATestExternalResource opencga = new OpenCGATestExternalResource(false);
-
-    @Test
-    public void myTest() throws ToolException, IOException {
-        Path outDir = Paths.get(opencga.createTmpOutdir("_nextflow"));
-
-        StopWatch stopWatch = StopWatch.createStarted();
-        NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
-        NextFlowRunParams runParams = new NextFlowRunParams("myId", 2);
-        nextFlowExecutorTest.setUp(opencga.getOpencgaHome().toString(), runParams.toObjectMap(), outDir, opencga.getAdminToken());
-        nextFlowExecutorTest.start();
-        System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
-    }
-
-}
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
new file mode 100644
index 00000000000..a54543cfc88
--- /dev/null
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -0,0 +1,86 @@
+package org.opencb.opencga.analysis.tools;
+
+import org.apache.commons.lang3.time.StopWatch;
+import org.junit.Test;
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.opencga.analysis.StorageManager;
+import org.opencb.opencga.catalog.exceptions.CatalogException;
+import org.opencb.opencga.catalog.managers.AbstractManagerTest;
+import org.opencb.opencga.core.config.storage.StorageConfiguration;
+import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.nextflow.NextFlowRunParams;
+import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.storage.core.StorageEngineFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.concurrent.TimeUnit;
+
+public class WorkflowExecutorTest extends AbstractManagerTest {
+
+    @Test
+    public void myTest() throws ToolException, CatalogException, IOException {
+        InputStream inputStream = StorageManager.class.getClassLoader().getResourceAsStream("storage-configuration.yml");
+        StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
+
+        Workflow workflow = getDummyWorkflow();
+        catalogManager.getWorkflowManager().create(workflow, QueryOptions.empty(), ownerToken);
+
+        Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
+
+        StopWatch stopWatch = StopWatch.createStarted();
+        NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
+        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1);
+        nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), catalogManager,
+                StorageEngineFactory.get(storageConfiguration), runParams.toObjectMap(), outDir, "", false, ownerToken);
+//        nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), runParams.toObjectMap(), outDir, ownerToken);
+        nextFlowExecutorTest.start();
+        System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
+    }
+
+    private Workflow getDummyWorkflow() {
+        String scriptContent = "params.str = 'Hello world!'\n" +
+                "\n" +
+                "process splitLetters {\n" +
+                "    output:\n" +
+                "    path 'chunk_*'\n" +
+                "\n" +
+                "    \"\"\"\n" +
+                "    printf '${params.str}' | split -b 6 - chunk_\n" +
+                "    \"\"\"\n" +
+                "}\n" +
+                "\n" +
+                "process convertToUpper {\n" +
+                "    input:\n" +
+                "    path x\n" +
+                "\n" +
+                "    output:\n" +
+                "    stdout\n" +
+                "\n" +
+                "    \"\"\"\n" +
+                "    cat $x | tr '[a-z]' '[A-Z]'\n" +
+                "    \"\"\"\n" +
+                "}\n" +
+                "\n" +
+                "process sleep {\n" +
+                "    input:\n" +
+                "    val x\n" +
+                "\n" +
+                "    \"\"\"\n" +
+                "    sleep 6\n" +
+                "    \"\"\"\n" +
+                "}\n" +
+                "\n" +
+                "workflow {\n" +
+                "    splitLetters | flatten | convertToUpper | view { it.trim() } | sleep\n" +
+                "}";
+        return new Workflow()
+                .setId("workflow")
+                .setCommandLine("run pipeline.nf")
+                .setType(Workflow.Type.NEXTFLOW)
+                .setScripts(Collections.singletonList(new Workflow.Script("pipeline.nf", scriptContent)));
+    }
+}
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/variant/OpenCGATestExternalResource.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/variant/OpenCGATestExternalResource.java
index 5c5956d7cf7..dbc8479305a 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/variant/OpenCGATestExternalResource.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/variant/OpenCGATestExternalResource.java
@@ -46,11 +46,8 @@
 import java.net.URI;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
-import java.text.SimpleDateFormat;
 import java.util.Arrays;
-import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
@@ -334,27 +331,15 @@ public void clearStorageDB() {
     }
 
     public String createTmpOutdir(String studyId, String suffix, String sessionId) throws CatalogException, IOException {
-        return createTmpOutdir(suffix);
+        return catalogManagerExternalResource.createTmpOutdir(suffix);
     }
 
     public String createTmpOutdir() throws IOException {
-        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
-        // stackTrace[0] = "Thread.currentThread"
-        // stackTrace[1] = "newOutputUri"
-        // stackTrace[2] =  caller method
-        String testName = stackTrace[2].getMethodName();
-        return createTmpOutdir(testName);
+        return catalogManagerExternalResource.createTmpOutdir();
     }
 
     public String createTmpOutdir(String suffix) throws IOException {
-        if (suffix.endsWith("_")) {
-            suffix = suffix.substring(0, suffix.length() - 1);
-        }
-        String folder = "I_tmp_" + new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss.SSS").format(new Date()) + suffix;
-        Path tmpOutDir = Paths.get(getCatalogManager().getConfiguration().getJobDir()).resolve(folder);
-        Files.createDirectories(tmpOutDir);
-        return tmpOutDir.toString();
-//        return getCatalogManager().getJobManager().createJobOutDir(studyId, "I_tmp_" + date + sufix, sessionId).toString();
+        return catalogManagerExternalResource.createTmpOutdir(suffix);
     }
 
 //    private class StorageLocalExecutorManager extends LocalExecutorManager {
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/DBAdaptorFactory.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/DBAdaptorFactory.java
index 5f3367d4d1c..607712bd8b0 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/DBAdaptorFactory.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/DBAdaptorFactory.java
@@ -117,4 +117,6 @@ OpenCGAResult<Organization> createOrganization(Organization organization, QueryO
     ClinicalAnalysisDBAdaptor getClinicalAnalysisDBAdaptor(String organization) throws CatalogDBException;
 
     InterpretationDBAdaptor getInterpretationDBAdaptor(String organization) throws CatalogDBException;
+
+    WorkflowDBAdaptor getWorkflowDBAdaptor(String organization) throws CatalogDBException;
 }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/NextFlowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
similarity index 71%
rename from opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/NextFlowDBAdaptor.java
rename to opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
index d3ee6a73bfc..cc9ebc9e96a 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/NextFlowDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
@@ -1,19 +1,30 @@
 package org.opencb.opencga.catalog.db.api;
 
 import org.apache.commons.collections4.map.LinkedMap;
+import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.commons.datastore.core.QueryParam;
-import org.opencb.opencga.core.models.nextflow.NextFlow;
+import org.opencb.opencga.catalog.exceptions.CatalogAuthorizationException;
+import org.opencb.opencga.catalog.exceptions.CatalogDBException;
+import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
+import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.response.OpenCGAResult;
 
 import java.util.Map;
 
 import static org.opencb.commons.datastore.core.QueryParam.Type.*;
 
-public interface NextFlowDBAdaptor extends CoreDBAdaptor<NextFlow> {
+public interface WorkflowDBAdaptor extends CoreDBAdaptor<Workflow> {
+
+    OpenCGAResult<Workflow> insert(Workflow workflow, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException;
 
     enum QueryParams implements QueryParam {
         ID("id", TEXT, ""),
         UID("uid", LONG, ""),
         UUID("uuid", TEXT, ""),
+        TYPE("type", TEXT, ""),
+        COMMAND_LINE("commandLine", TEXT, ""),
+        SCRIPTS("scripts", OBJECT, ""),
         RELEASE("release", INTEGER, ""), //  Release where the sample was created
         SNAPSHOT("snapshot", INTEGER, ""), // Last version of sample at release = snapshot
         VERSION("version", INTEGER, ""), // Version of the sample
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/MongoDBAdaptorFactory.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/MongoDBAdaptorFactory.java
index 621c537cddd..9cb82011a1b 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/MongoDBAdaptorFactory.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/MongoDBAdaptorFactory.java
@@ -400,6 +400,11 @@ public InterpretationDBAdaptor getInterpretationDBAdaptor(String organizationId)
         return getOrganizationMongoDBAdaptorFactory(organizationId).getInterpretationDBAdaptor();
     }
 
+    @Override
+    public WorkflowDBAdaptor getWorkflowDBAdaptor(String organization) throws CatalogDBException {
+        return getOrganizationMongoDBAdaptorFactory(organization).getWorkflowDBAdaptor();
+    }
+
     public MongoDataStoreManager getMongoManager() {
         return mongoManager;
     }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/NextFlowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/NextFlowMongoDBAdaptor.java
deleted file mode 100644
index 401f0f28872..00000000000
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/NextFlowMongoDBAdaptor.java
+++ /dev/null
@@ -1,259 +0,0 @@
-package org.opencb.opencga.catalog.db.mongodb;
-
-import com.mongodb.client.ClientSession;
-import org.apache.commons.lang3.time.StopWatch;
-import org.bson.Document;
-import org.bson.conversions.Bson;
-import org.opencb.commons.datastore.core.ObjectMap;
-import org.opencb.commons.datastore.core.Query;
-import org.opencb.commons.datastore.core.QueryOptions;
-import org.opencb.commons.datastore.mongodb.MongoDBCollection;
-import org.opencb.commons.datastore.mongodb.MongoDBIterator;
-import org.opencb.opencga.catalog.db.api.DBIterator;
-import org.opencb.opencga.catalog.db.api.NextFlowDBAdaptor;
-import org.opencb.opencga.catalog.db.mongodb.converters.NextFlowConverter;
-import org.opencb.opencga.catalog.db.mongodb.iterators.NextFlowCatalogMongoDBIterator;
-import org.opencb.opencga.catalog.exceptions.CatalogAuthorizationException;
-import org.opencb.opencga.catalog.exceptions.CatalogDBException;
-import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
-import org.opencb.opencga.core.config.Configuration;
-import org.opencb.opencga.core.models.nextflow.NextFlow;
-import org.opencb.opencga.core.response.OpenCGAResult;
-import org.slf4j.LoggerFactory;
-
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-import java.util.function.Consumer;
-
-import static org.opencb.opencga.catalog.db.mongodb.MongoDBUtils.fixAclProjection;
-
-public class NextFlowMongoDBAdaptor extends CatalogMongoDBAdaptor implements NextFlowDBAdaptor {
-
-    private final MongoDBCollection nextflowCollection;
-    private final MongoDBCollection archiveNextflowCollection;
-    private final MongoDBCollection deleteNextflowCollection;
-    private final SnapshotVersionedMongoDBAdaptor versionedMongoDBAdaptor;
-    private final NextFlowConverter nextflowConverter;
-
-    public NextFlowMongoDBAdaptor(MongoDBCollection nextflowCollection, MongoDBCollection archiveNextflowCollection,
-                                  MongoDBCollection deleteNextflowCollection, Configuration configuration,
-                                  OrganizationMongoDBAdaptorFactory dbAdaptorFactory) {
-        super(configuration, LoggerFactory.getLogger(NextFlowMongoDBAdaptor.class));
-        this.dbAdaptorFactory = dbAdaptorFactory;
-        this.nextflowCollection = nextflowCollection;
-        this.archiveNextflowCollection = archiveNextflowCollection;
-        this.deleteNextflowCollection = deleteNextflowCollection;
-        this.versionedMongoDBAdaptor = new SnapshotVersionedMongoDBAdaptor(nextflowCollection, archiveNextflowCollection,
-                deleteNextflowCollection);
-        this.nextflowConverter = new NextFlowConverter();
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> get(long studyUid, Query query, QueryOptions options, String user)
-            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
-        long startTime = startQuery();
-        try (DBIterator<NextFlow> dbIterator = iterator(studyUid, query, options, user)) {
-            return endQuery(startTime, dbIterator);
-        }
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> get(Query query, QueryOptions options)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        long startTime = startQuery();
-        try (DBIterator<NextFlow> dbIterator = iterator(query, options)) {
-            return endQuery(startTime, dbIterator);
-        }
-    }
-
-    @Override
-    public OpenCGAResult nativeGet(long studyUid, Query query, QueryOptions options, String user)
-            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
-        long startTime = startQuery();
-        try (DBIterator<Document> dbIterator = nativeIterator(studyUid, query, options, user)) {
-            return endQuery(startTime, dbIterator);
-        }
-    }
-
-    @Override
-    OpenCGAResult<Document> nativeGet(Query query, QueryOptions options)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        long startTime = startQuery();
-        try (DBIterator<Document> dbIterator = nativeIterator(query, options)) {
-            return endQuery(startTime, dbIterator);
-        }
-    }
-
-    @Override
-    public DBIterator<NextFlow> iterator(long studyUid, Query query, QueryOptions options, String user)
-            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
-        query.put(PRIVATE_STUDY_UID, studyUid);
-        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, options, user);
-        return new NextFlowCatalogMongoDBIterator<>(mongoCursor, null, nextflowConverter, null, studyUid, user, options);
-    }
-
-    @Override
-    public DBIterator<NextFlow> iterator(Query query, QueryOptions options)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, options, null);
-        return new NextFlowCatalogMongoDBIterator<>(mongoCursor, null, nextflowConverter, null, options);
-    }
-
-    @Override
-    public DBIterator nativeIterator(Query query, QueryOptions options)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        QueryOptions queryOptions = options != null ? new QueryOptions(options) : new QueryOptions();
-        queryOptions.put(NATIVE_QUERY, true);
-        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, queryOptions, null);
-        return new NextFlowCatalogMongoDBIterator(mongoCursor, null, null, null, options);
-    }
-
-    @Override
-    public DBIterator nativeIterator(long studyUid, Query query, QueryOptions options, String user)
-            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
-        QueryOptions queryOptions = options != null ? new QueryOptions(options) : new QueryOptions();
-        queryOptions.put(NATIVE_QUERY, true);
-
-        query.put(PRIVATE_STUDY_UID, studyUid);
-        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, queryOptions, user);
-        return new NextFlowCatalogMongoDBIterator<>(mongoCursor, null, null, null, studyUid, user, options);
-    }
-
-    @Override
-    public OpenCGAResult<Long> count(Query query, String user)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        Bson bson = parseQuery(query, user);
-        return new OpenCGAResult<>(nextflowCollection.count(null, bson));
-    }
-
-    @Override
-    public OpenCGAResult<Long> count(Query query)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        Bson bson = parseQuery(query);
-        return new OpenCGAResult<>(nextflowCollection.count(null, bson));
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> groupBy(Query query, List<String> fields, QueryOptions options, String user)
-            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
-        return null;
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> groupBy(Query query, String field, QueryOptions options)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        Bson bsonQuery = parseQuery(query);
-        return groupBy(nextflowCollection, bsonQuery, field, NextFlowDBAdaptor.QueryParams.ID.key(), options);
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> groupBy(Query query, List<String> fields, QueryOptions options)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        Bson bsonQuery = parseQuery(query);
-        return groupBy(nextflowCollection, bsonQuery, fields, NextFlowDBAdaptor.QueryParams.ID.key(), options);
-    }
-
-    @Override
-    public OpenCGAResult<?> distinct(long studyUid, String field, Query query, String userId)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        Query finalQuery = query != null ? new Query(query) : new Query();
-        finalQuery.put(NextFlowDBAdaptor.QueryParams.STUDY_UID.key(), studyUid);
-        Bson bson = parseQuery(finalQuery, userId);
-        return new OpenCGAResult<>(nextflowCollection.distinct(field, bson));
-    }
-
-    @Override
-    public OpenCGAResult<?> distinct(long studyUid, List<String> fields, Query query, String userId)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        StopWatch stopWatch = StopWatch.createStarted();
-        Query finalQuery = query != null ? new Query(query) : new Query();
-        finalQuery.put(NextFlowDBAdaptor.QueryParams.STUDY_UID.key(), studyUid);
-        Bson bson = parseQuery(finalQuery, userId);
-
-        Set<String> results = new LinkedHashSet<>();
-        for (String field : fields) {
-            results.addAll(nextflowCollection.distinct(field, bson, String.class).getResults());
-        }
-
-        return new OpenCGAResult<>((int) stopWatch.getTime(TimeUnit.MILLISECONDS), Collections.emptyList(), results.size(),
-                new ArrayList<>(results), -1);
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> stats(Query query) {
-        return null;
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> update(long id, ObjectMap parameters, QueryOptions queryOptions)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> update(Query query, ObjectMap parameters, QueryOptions queryOptions)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> delete(NextFlow id) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> delete(Query query) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> restore(long id, QueryOptions queryOptions) throws CatalogDBException {
-        return null;
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> restore(Query query, QueryOptions queryOptions) throws CatalogDBException {
-        return null;
-    }
-
-    @Override
-    public OpenCGAResult<NextFlow> rank(Query query, String field, int numResults, boolean asc)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
-    }
-
-    @Override
-    public void forEach(Query query, Consumer<? super Object> action, QueryOptions options)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-
-    }
-
-
-    private MongoDBIterator<Document> getMongoCursor(ClientSession clientSession, Query query, QueryOptions options, String user)
-            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        Query finalQuery = new Query(query);
-
-        QueryOptions qOptions;
-        if (options != null) {
-            qOptions = new QueryOptions(options);
-        } else {
-            qOptions = new QueryOptions();
-        }
-        fixAclProjection(qOptions);
-
-        Bson bson = parseQuery(finalQuery, user);
-        MongoDBCollection collection = getQueryCollection(finalQuery, nextflowCollection, archiveNextflowCollection,
-                deleteNextflowCollection);
-        logger.debug("Nextflow query: {}", bson.toBsonDocument());
-        return collection.iterator(clientSession, bson, null, null, qOptions);
-    }
-
-
-    private Bson parseQuery(Query query) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return parseQuery(query, null);
-    }
-
-    private Bson parseQuery(Query query, String user) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
-    }
-}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/OrganizationMongoDBAdaptorFactory.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/OrganizationMongoDBAdaptorFactory.java
index b1c1c6704ec..591825374fe 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/OrganizationMongoDBAdaptorFactory.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/OrganizationMongoDBAdaptorFactory.java
@@ -42,6 +42,7 @@ public class OrganizationMongoDBAdaptorFactory {
     public static final String PANEL_COLLECTION = "panel";
     public static final String CLINICAL_ANALYSIS_COLLECTION = "clinical";
     public static final String INTERPRETATION_COLLECTION = "interpretation";
+    public static final String WORKFLOW_COLLECTION = "workflow";
 
     public static final String NOTE_ARCHIVE_COLLECTION = "note_archive";
     public static final String SAMPLE_ARCHIVE_COLLECTION = "sample_archive";
@@ -49,6 +50,7 @@ public class OrganizationMongoDBAdaptorFactory {
     public static final String FAMILY_ARCHIVE_COLLECTION = "family_archive";
     public static final String PANEL_ARCHIVE_COLLECTION = "panel_archive";
     public static final String INTERPRETATION_ARCHIVE_COLLECTION = "interpretation_archive";
+    public static final String WORKFLOW_ARCHIVE_COLLECTION = "workflow_archive";
 
     public static final String DELETED_NOTE_COLLECTION = "note_deleted";
     public static final String DELETED_USER_COLLECTION = "user_deleted";
@@ -63,6 +65,7 @@ public class OrganizationMongoDBAdaptorFactory {
     public static final String DELETED_PANEL_COLLECTION = "panel_deleted";
     public static final String DELETED_CLINICAL_ANALYSIS_COLLECTION = "clinical_deleted";
     public static final String DELETED_INTERPRETATION_COLLECTION = "interpretation_deleted";
+    public static final String DELETED_WORKFLOW_COLLECTION = "workflow_deleted";
 
     public static final String METADATA_COLLECTION = "metadata";
     public static final String MIGRATION_COLLECTION = "migration";
@@ -83,6 +86,7 @@ public class OrganizationMongoDBAdaptorFactory {
             FAMILY_COLLECTION,
             CLINICAL_ANALYSIS_COLLECTION,
             INTERPRETATION_COLLECTION,
+            WORKFLOW_COLLECTION,
 
             NOTE_ARCHIVE_COLLECTION,
             SAMPLE_ARCHIVE_COLLECTION,
@@ -90,6 +94,7 @@ public class OrganizationMongoDBAdaptorFactory {
             FAMILY_ARCHIVE_COLLECTION,
             PANEL_ARCHIVE_COLLECTION,
             INTERPRETATION_ARCHIVE_COLLECTION,
+            WORKFLOW_ARCHIVE_COLLECTION,
 
             DELETED_NOTE_COLLECTION,
             DELETED_USER_COLLECTION,
@@ -104,6 +109,7 @@ public class OrganizationMongoDBAdaptorFactory {
             DELETED_FAMILY_COLLECTION,
             DELETED_CLINICAL_ANALYSIS_COLLECTION,
             DELETED_INTERPRETATION_COLLECTION,
+            DELETED_WORKFLOW_COLLECTION,
 
             MIGRATION_COLLECTION,
             // FIXME metadata collection is unused
@@ -131,6 +137,7 @@ public class OrganizationMongoDBAdaptorFactory {
     private final PanelMongoDBAdaptor panelDBAdaptor;
     private final ClinicalAnalysisMongoDBAdaptor clinicalDBAdaptor;
     private final InterpretationMongoDBAdaptor interpretationDBAdaptor;
+    private final WorkflowMongoDBAdaptor workflowDBAdaptor;
     private final AuditMongoDBAdaptor auditDBAdaptor;
 //    private final MetaMongoDBAdaptor metaDBAdaptor;
     private final MigrationMongoDBAdaptor migrationDBAdaptor;
@@ -170,6 +177,7 @@ public OrganizationMongoDBAdaptorFactory(String organizationId, MongoDataStoreMa
         MongoDBCollection familyCollection = mongoDataStore.getCollection(FAMILY_COLLECTION);
         MongoDBCollection clinicalCollection = mongoDataStore.getCollection(CLINICAL_ANALYSIS_COLLECTION);
         MongoDBCollection interpretationCollection = mongoDataStore.getCollection(INTERPRETATION_COLLECTION);
+        MongoDBCollection workflowCollection = mongoDataStore.getCollection(WORKFLOW_COLLECTION);
 
         MongoDBCollection notesArchivedCollection = mongoDataStore.getCollection(NOTE_ARCHIVE_COLLECTION);
         MongoDBCollection sampleArchivedCollection = mongoDataStore.getCollection(SAMPLE_ARCHIVE_COLLECTION);
@@ -177,6 +185,7 @@ public OrganizationMongoDBAdaptorFactory(String organizationId, MongoDataStoreMa
         MongoDBCollection familyArchivedCollection = mongoDataStore.getCollection(FAMILY_ARCHIVE_COLLECTION);
         MongoDBCollection panelArchivedCollection = mongoDataStore.getCollection(PANEL_ARCHIVE_COLLECTION);
         MongoDBCollection interpretationArchivedCollection = mongoDataStore.getCollection(INTERPRETATION_ARCHIVE_COLLECTION);
+        MongoDBCollection workflowArchivedCollection = mongoDataStore.getCollection(WORKFLOW_ARCHIVE_COLLECTION);
 
         MongoDBCollection deletedNotesCollection = mongoDataStore.getCollection(DELETED_NOTE_COLLECTION);
         MongoDBCollection deletedUserCollection = mongoDataStore.getCollection(DELETED_USER_COLLECTION);
@@ -191,6 +200,7 @@ public OrganizationMongoDBAdaptorFactory(String organizationId, MongoDataStoreMa
         MongoDBCollection deletedFamilyCollection = mongoDataStore.getCollection(DELETED_FAMILY_COLLECTION);
         MongoDBCollection deletedClinicalCollection = mongoDataStore.getCollection(DELETED_CLINICAL_ANALYSIS_COLLECTION);
         MongoDBCollection deletedInterpretationCollection = mongoDataStore.getCollection(DELETED_INTERPRETATION_COLLECTION);
+        MongoDBCollection deletedWorkflowCollection = mongoDataStore.getCollection(DELETED_WORKFLOW_COLLECTION);
 
         MongoDBCollection auditCollection = mongoDataStore.getCollection(AUDIT_COLLECTION);
 
@@ -214,6 +224,8 @@ public OrganizationMongoDBAdaptorFactory(String organizationId, MongoDataStoreMa
         clinicalDBAdaptor = new ClinicalAnalysisMongoDBAdaptor(clinicalCollection, deletedClinicalCollection, configuration, this);
         interpretationDBAdaptor = new InterpretationMongoDBAdaptor(interpretationCollection, interpretationArchivedCollection,
                 deletedInterpretationCollection, configuration, this);
+        workflowDBAdaptor = new WorkflowMongoDBAdaptor(workflowCollection, workflowArchivedCollection, deletedWorkflowCollection,
+                configuration, this);
 //        metaDBAdaptor = new MetaMongoDBAdaptor(metaCollection, configuration, this);
         migrationDBAdaptor = new MigrationMongoDBAdaptor(migrationCollection, configuration, this);
         auditDBAdaptor = new AuditMongoDBAdaptor(auditCollection, configuration);
@@ -237,6 +249,7 @@ public OrganizationMongoDBAdaptorFactory(String organizationId, MongoDataStoreMa
         mongoDBCollectionMap.put(FAMILY_COLLECTION, familyCollection);
         mongoDBCollectionMap.put(CLINICAL_ANALYSIS_COLLECTION, clinicalCollection);
         mongoDBCollectionMap.put(INTERPRETATION_COLLECTION, interpretationCollection);
+        mongoDBCollectionMap.put(WORKFLOW_COLLECTION, workflowCollection);
 
         mongoDBCollectionMap.put(NOTE_ARCHIVE_COLLECTION, notesArchivedCollection);
         mongoDBCollectionMap.put(SAMPLE_ARCHIVE_COLLECTION, sampleArchivedCollection);
@@ -244,6 +257,7 @@ public OrganizationMongoDBAdaptorFactory(String organizationId, MongoDataStoreMa
         mongoDBCollectionMap.put(FAMILY_ARCHIVE_COLLECTION, familyArchivedCollection);
         mongoDBCollectionMap.put(PANEL_ARCHIVE_COLLECTION, panelArchivedCollection);
         mongoDBCollectionMap.put(INTERPRETATION_ARCHIVE_COLLECTION, interpretationArchivedCollection);
+        mongoDBCollectionMap.put(WORKFLOW_ARCHIVE_COLLECTION, workflowArchivedCollection);
 
         mongoDBCollectionMap.put(DELETED_NOTE_COLLECTION, deletedNotesCollection);
         mongoDBCollectionMap.put(DELETED_USER_COLLECTION, deletedUserCollection);
@@ -257,6 +271,7 @@ public OrganizationMongoDBAdaptorFactory(String organizationId, MongoDataStoreMa
         mongoDBCollectionMap.put(DELETED_FAMILY_COLLECTION, deletedFamilyCollection);
         mongoDBCollectionMap.put(DELETED_CLINICAL_ANALYSIS_COLLECTION, deletedClinicalCollection);
         mongoDBCollectionMap.put(DELETED_INTERPRETATION_COLLECTION, deletedInterpretationCollection);
+        mongoDBCollectionMap.put(DELETED_WORKFLOW_COLLECTION, deletedWorkflowCollection);
 
         mongoDBCollectionMap.put(AUDIT_COLLECTION, auditCollection);
     }
@@ -478,6 +493,10 @@ public InterpretationMongoDBAdaptor getInterpretationDBAdaptor() {
         return interpretationDBAdaptor;
     }
 
+    public WorkflowMongoDBAdaptor getWorkflowDBAdaptor() {
+        return workflowDBAdaptor;
+    }
+
     public AuthorizationMongoDBAdaptor getAuthorizationDBAdaptor() {
         return authorizationMongoDBAdaptor;
     }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
index a86ebb9cc36..1c782686bf7 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
@@ -138,6 +138,9 @@ DBIterator<T> iterator(ClientSession session, Query query, QueryOptions options)
 
     protected void insert(ClientSession session, Document document) {
         String uuid = getClientSessionUuid(session);
+        document.put(VERSION, 1);
+        document.put(LAST_OF_VERSION, true);
+        document.put(LAST_OF_RELEASE, true);
         document.put(PRIVATE_TRANSACTION_ID, uuid);
         collection.insert(session, document, QueryOptions.empty());
         archiveCollection.insert(session, document, QueryOptions.empty());
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
new file mode 100644
index 00000000000..809550306c0
--- /dev/null
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -0,0 +1,386 @@
+package org.opencb.opencga.catalog.db.mongodb;
+
+import com.mongodb.client.ClientSession;
+import com.mongodb.client.model.Filters;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.StopWatch;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.opencb.commons.datastore.core.DataResult;
+import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.commons.datastore.core.Query;
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.commons.datastore.mongodb.MongoDBCollection;
+import org.opencb.commons.datastore.mongodb.MongoDBIterator;
+import org.opencb.opencga.catalog.db.api.DBIterator;
+import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
+import org.opencb.opencga.catalog.db.mongodb.converters.WorkflowConverter;
+import org.opencb.opencga.catalog.db.mongodb.iterators.WorkflowCatalogMongoDBIterator;
+import org.opencb.opencga.catalog.exceptions.CatalogAuthorizationException;
+import org.opencb.opencga.catalog.exceptions.CatalogDBException;
+import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
+import org.opencb.opencga.catalog.utils.Constants;
+import org.opencb.opencga.core.common.TimeUtils;
+import org.opencb.opencga.core.config.Configuration;
+import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.response.OpenCGAResult;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+import static org.opencb.opencga.catalog.db.mongodb.MongoDBUtils.fixAclProjection;
+
+public class WorkflowMongoDBAdaptor extends CatalogMongoDBAdaptor implements WorkflowDBAdaptor {
+
+    private final MongoDBCollection workflowCollection;
+    private final MongoDBCollection archiveWorkflowCollection;
+    private final MongoDBCollection deleteWorkflowCollection;
+    private final SnapshotVersionedMongoDBAdaptor versionedMongoDBAdaptor;
+    private final WorkflowConverter workflowConverter;
+
+    public WorkflowMongoDBAdaptor(MongoDBCollection workflowCollection, MongoDBCollection archiveWorkflowCollection,
+                                  MongoDBCollection deleteWorkflowCollection, Configuration configuration,
+                                  OrganizationMongoDBAdaptorFactory dbAdaptorFactory) {
+        super(configuration, LoggerFactory.getLogger(WorkflowMongoDBAdaptor.class));
+        this.dbAdaptorFactory = dbAdaptorFactory;
+        this.workflowCollection = workflowCollection;
+        this.archiveWorkflowCollection = archiveWorkflowCollection;
+        this.deleteWorkflowCollection = deleteWorkflowCollection;
+        this.versionedMongoDBAdaptor = new SnapshotVersionedMongoDBAdaptor(workflowCollection, archiveWorkflowCollection,
+                deleteWorkflowCollection);
+        this.workflowConverter = new WorkflowConverter();
+    }
+
+    Workflow insert(ClientSession clientSession, Workflow workflow) throws CatalogDBException {
+        if (StringUtils.isEmpty(workflow.getId())) {
+            throw new CatalogDBException("Missing workflow id");
+        }
+
+        // Check the workflow does not exist
+        Bson bson = Filters.eq(QueryParams.ID.key(), workflow.getId());
+        DataResult<Long> count = workflowCollection.count(clientSession, bson);
+        if (count.getNumMatches() > 0) {
+            throw new CatalogDBException("Workflow { id: '" + workflow.getId() + "'} already exists.");
+        }
+
+        long uid = getNewUid(clientSession);
+        workflow.setUid(uid);
+
+        Document workflowObject = workflowConverter.convertToStorageType(workflow);
+
+        workflowObject.put(PRIVATE_CREATION_DATE,
+                StringUtils.isNotEmpty(workflow.getCreationDate()) ? TimeUtils.toDate(workflow.getCreationDate()) : TimeUtils.getDate());
+        workflowObject.put(PRIVATE_MODIFICATION_DATE, StringUtils.isNotEmpty(workflow.getModificationDate())
+                ? TimeUtils.toDate(workflow.getModificationDate()) : TimeUtils.getDate());
+
+        logger.debug("Inserting workflow '{}' ({})...", workflow.getId(), workflow.getUid());
+        versionedMongoDBAdaptor.insert(clientSession, workflowObject);
+        logger.debug("Workflow '{}' successfully inserted", workflow.getId());
+
+        return workflow;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> insert(Workflow workflow, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return runTransaction(clientSession -> {
+            long tmpStartTime = startQuery();
+            logger.debug("Starting workflow insert transaction for workflow id '{}'", workflow.getId());
+
+            insert(clientSession, workflow);
+            return endWrite(tmpStartTime, 1, 1, 0, 0, null);
+        }, e -> logger.error("Could not create workflow {}: {}", workflow.getId(), e.getMessage()));
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> get(long studyUid, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        long startTime = startQuery();
+        try (DBIterator<Workflow> dbIterator = iterator(studyUid, query, options, user)) {
+            return endQuery(startTime, dbIterator);
+        }
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> get(Query query, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        long startTime = startQuery();
+        try (DBIterator<Workflow> dbIterator = iterator(query, options)) {
+            return endQuery(startTime, dbIterator);
+        }
+    }
+
+    @Override
+    public OpenCGAResult nativeGet(long studyUid, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        long startTime = startQuery();
+        try (DBIterator<Document> dbIterator = nativeIterator(studyUid, query, options, user)) {
+            return endQuery(startTime, dbIterator);
+        }
+    }
+
+    @Override
+    OpenCGAResult<Document> nativeGet(Query query, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        long startTime = startQuery();
+        try (DBIterator<Document> dbIterator = nativeIterator(query, options)) {
+            return endQuery(startTime, dbIterator);
+        }
+    }
+
+    @Override
+    public DBIterator<Workflow> iterator(long studyUid, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        query.put(PRIVATE_STUDY_UID, studyUid);
+        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, options, user);
+        return new WorkflowCatalogMongoDBIterator<>(mongoCursor, null, workflowConverter, null, studyUid, user, options);
+    }
+
+    @Override
+    public DBIterator<Workflow> iterator(Query query, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, options, null);
+        return new WorkflowCatalogMongoDBIterator<>(mongoCursor, null, workflowConverter, null, options);
+    }
+
+    @Override
+    public DBIterator nativeIterator(Query query, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        QueryOptions queryOptions = options != null ? new QueryOptions(options) : new QueryOptions();
+        queryOptions.put(NATIVE_QUERY, true);
+        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, queryOptions, null);
+        return new WorkflowCatalogMongoDBIterator(mongoCursor, null, null, null, options);
+    }
+
+    @Override
+    public DBIterator nativeIterator(long studyUid, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        QueryOptions queryOptions = options != null ? new QueryOptions(options) : new QueryOptions();
+        queryOptions.put(NATIVE_QUERY, true);
+
+        query.put(PRIVATE_STUDY_UID, studyUid);
+        MongoDBIterator<Document> mongoCursor = getMongoCursor(null, query, queryOptions, user);
+        return new WorkflowCatalogMongoDBIterator<>(mongoCursor, null, null, null, studyUid, user, options);
+    }
+
+    @Override
+    public OpenCGAResult<Long> count(Query query, String user)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Bson bson = parseQuery(query, user);
+        return new OpenCGAResult<>(workflowCollection.count(null, bson));
+    }
+
+    @Override
+    public OpenCGAResult<Long> count(Query query)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Bson bson = parseQuery(query);
+        return new OpenCGAResult<>(workflowCollection.count(null, bson));
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> groupBy(Query query, List<String> fields, QueryOptions options, String user)
+            throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> groupBy(Query query, String field, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Bson bsonQuery = parseQuery(query);
+        return groupBy(workflowCollection, bsonQuery, field, WorkflowDBAdaptor.QueryParams.ID.key(), options);
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> groupBy(Query query, List<String> fields, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Bson bsonQuery = parseQuery(query);
+        return groupBy(workflowCollection, bsonQuery, fields, WorkflowDBAdaptor.QueryParams.ID.key(), options);
+    }
+
+    @Override
+    public OpenCGAResult<?> distinct(long studyUid, String field, Query query, String userId)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Query finalQuery = query != null ? new Query(query) : new Query();
+        finalQuery.put(WorkflowDBAdaptor.QueryParams.STUDY_UID.key(), studyUid);
+        Bson bson = parseQuery(finalQuery, userId);
+        return new OpenCGAResult<>(workflowCollection.distinct(field, bson));
+    }
+
+    @Override
+    public OpenCGAResult<?> distinct(long studyUid, List<String> fields, Query query, String userId)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        StopWatch stopWatch = StopWatch.createStarted();
+        Query finalQuery = query != null ? new Query(query) : new Query();
+        finalQuery.put(WorkflowDBAdaptor.QueryParams.STUDY_UID.key(), studyUid);
+        Bson bson = parseQuery(finalQuery, userId);
+
+        Set<String> results = new LinkedHashSet<>();
+        for (String field : fields) {
+            results.addAll(workflowCollection.distinct(field, bson, String.class).getResults());
+        }
+
+        return new OpenCGAResult<>((int) stopWatch.getTime(TimeUnit.MILLISECONDS), Collections.emptyList(), results.size(),
+                new ArrayList<>(results), -1);
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> stats(Query query) {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> update(long id, ObjectMap parameters, QueryOptions queryOptions)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> update(Query query, ObjectMap parameters, QueryOptions queryOptions)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> delete(Workflow id) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> delete(Query query) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> restore(long id, QueryOptions queryOptions) throws CatalogDBException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> restore(Query query, QueryOptions queryOptions) throws CatalogDBException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> rank(Query query, String field, int numResults, boolean asc)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return null;
+    }
+
+    @Override
+    public void forEach(Query query, Consumer<? super Object> action, QueryOptions options)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+
+    }
+
+
+    private MongoDBIterator<Document> getMongoCursor(ClientSession clientSession, Query query, QueryOptions options, String user)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        Query finalQuery = new Query(query);
+
+        QueryOptions qOptions;
+        if (options != null) {
+            qOptions = new QueryOptions(options);
+        } else {
+            qOptions = new QueryOptions();
+        }
+        fixAclProjection(qOptions);
+
+        Bson bson = parseQuery(finalQuery, user);
+        MongoDBCollection collection = getQueryCollection(finalQuery, workflowCollection, archiveWorkflowCollection,
+                deleteWorkflowCollection);
+        logger.debug("Nextflow query: {}", bson.toBsonDocument());
+        return collection.iterator(clientSession, bson, null, null, qOptions);
+    }
+
+
+    private Bson parseQuery(Query query) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return parseQuery(query, null);
+    }
+
+    private Bson parseQuery(Query query, String user) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        List<Bson> andBsonList = new ArrayList<>();
+
+        Query queryCopy = new Query(query);
+//        queryCopy.remove(WorkflowDBAdaptor.QueryParams.DELETED.key());
+
+        if ("all".equalsIgnoreCase(queryCopy.getString(WorkflowDBAdaptor.QueryParams.VERSION.key()))) {
+            queryCopy.put(Constants.ALL_VERSIONS, true);
+            queryCopy.remove(WorkflowDBAdaptor.QueryParams.VERSION.key());
+        }
+
+        boolean uidVersionQueryFlag = versionedMongoDBAdaptor.generateUidVersionQuery(queryCopy, andBsonList);
+
+        for (Map.Entry<String, Object> entry : queryCopy.entrySet()) {
+            String key = entry.getKey().split("\\.")[0];
+            WorkflowDBAdaptor.QueryParams queryParam = WorkflowDBAdaptor.QueryParams.getParam(entry.getKey()) != null
+                    ? WorkflowDBAdaptor.QueryParams.getParam(entry.getKey())
+                    : WorkflowDBAdaptor.QueryParams.getParam(key);
+            if (queryParam == null) {
+                if (Constants.ALL_VERSIONS.equals(entry.getKey())) {
+                    continue;
+                }
+                throw new CatalogDBException("Unexpected parameter " + entry.getKey() + ". The parameter does not exist or cannot be "
+                        + "queried for.");
+            }
+            try {
+                switch (queryParam) {
+                    case UID:
+                        addAutoOrQuery(PRIVATE_UID, queryParam.key(), queryCopy, queryParam.type(), andBsonList);
+                        break;
+//                    case SNAPSHOT:
+//                        addAutoOrQuery(RELEASE_FROM_VERSION, queryParam.key(), queryCopy, queryParam.type(), andBsonList);
+//                        break;
+                    case CREATION_DATE:
+                        addAutoOrQuery(PRIVATE_CREATION_DATE, queryParam.key(), queryCopy, queryParam.type(), andBsonList);
+                        break;
+                    case MODIFICATION_DATE:
+                        addAutoOrQuery(PRIVATE_MODIFICATION_DATE, queryParam.key(), query, queryParam.type(), andBsonList);
+                        break;
+//                    case STATUS:
+//                    case STATUS_ID:
+//                        addAutoOrQuery(WorkflowDBAdaptor.QueryParams.STATUS_ID.key(), queryParam.key(), query,
+//                        WorkflowDBAdaptor.QueryParams.STATUS_ID.type(), andBsonList);
+//                        break;
+//                    case INTERNAL_STATUS:
+//                    case INTERNAL_STATUS_ID:
+//                        // Convert the status to a positive status
+//                        query.put(queryParam.key(), InternalStatus.getPositiveStatus(InternalStatus.STATUS_LIST,
+//                                query.getString(queryParam.key())));
+//                        addAutoOrQuery(WorkflowDBAdaptor.QueryParams.INTERNAL_STATUS_ID.key(), queryParam.key(), query,
+//                                WorkflowDBAdaptor.QueryParams.INTERNAL_STATUS_ID.type(), andBsonList);
+//                        break;
+                    case ID:
+                    case UUID:
+                    case RELEASE:
+                    case VERSION:
+                        addAutoOrQuery(queryParam.key(), queryParam.key(), queryCopy, queryParam.type(), andBsonList);
+                        break;
+                    default:
+                        throw new CatalogDBException("Cannot query by parameter " + queryParam.key());
+                }
+            } catch (Exception e) {
+                if (e instanceof CatalogDBException) {
+                    throw e;
+                } else {
+                    throw new CatalogDBException("Error parsing query : " + queryCopy.toJson(), e);
+                }
+            }
+        }
+
+        // If the user doesn't look for a concrete version...
+        if (!uidVersionQueryFlag && !queryCopy.getBoolean(Constants.ALL_VERSIONS)
+                && !queryCopy.containsKey(WorkflowDBAdaptor.QueryParams.VERSION.key())
+                && queryCopy.containsKey(WorkflowDBAdaptor.QueryParams.SNAPSHOT.key())) {
+            // If the user looks for anything from some release, we will try to find the latest from the release (snapshot)
+            andBsonList.add(Filters.eq(LAST_OF_RELEASE, true));
+        }
+
+        if (andBsonList.size() > 0) {
+            return Filters.and(andBsonList);
+        } else {
+            return new Document();
+        }
+    }
+}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/NextFlowConverter.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/NextFlowConverter.java
deleted file mode 100644
index 6abbee7e1fd..00000000000
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/NextFlowConverter.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.opencb.opencga.catalog.db.mongodb.converters;
-
-import org.opencb.opencga.core.models.nextflow.NextFlow;
-
-public class NextFlowConverter extends OpenCgaMongoConverter<NextFlow> {
-
-    public NextFlowConverter() {
-        super(NextFlow.class);
-    }
-}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
new file mode 100644
index 00000000000..589220cacaa
--- /dev/null
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
@@ -0,0 +1,10 @@
+package org.opencb.opencga.catalog.db.mongodb.converters;
+
+import org.opencb.opencga.core.models.nextflow.Workflow;
+
+public class WorkflowConverter extends OpenCgaMongoConverter<Workflow> {
+
+    public WorkflowConverter() {
+        super(Workflow.class);
+    }
+}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/NextFlowCatalogMongoDBIterator.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/WorkflowCatalogMongoDBIterator.java
similarity index 75%
rename from opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/NextFlowCatalogMongoDBIterator.java
rename to opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/WorkflowCatalogMongoDBIterator.java
index 05e279f4965..bef72d87cd5 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/NextFlowCatalogMongoDBIterator.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/iterators/WorkflowCatalogMongoDBIterator.java
@@ -12,7 +12,7 @@
 import java.util.LinkedList;
 import java.util.Queue;
 
-public class NextFlowCatalogMongoDBIterator<E> extends CatalogMongoDBIterator<E> {
+public class WorkflowCatalogMongoDBIterator<E> extends CatalogMongoDBIterator<E> {
 
     private long studyUid;
     private String user;
@@ -25,13 +25,13 @@ public class NextFlowCatalogMongoDBIterator<E> extends CatalogMongoDBIterator<E>
     private static final int BUFFER_SIZE = 100;
     private static final String UID_VERSION_SEP = "___";
 
-    public NextFlowCatalogMongoDBIterator(MongoDBIterator<Document> mongoCursor, ClientSession clientSession,
-                                                GenericDocumentComplexConverter<E> converter,
-                                                OrganizationMongoDBAdaptorFactory dbAdaptorFactory, QueryOptions options) {
+    public WorkflowCatalogMongoDBIterator(MongoDBIterator<Document> mongoCursor, ClientSession clientSession,
+                                          GenericDocumentComplexConverter<E> converter,
+                                          OrganizationMongoDBAdaptorFactory dbAdaptorFactory, QueryOptions options) {
         this(mongoCursor, clientSession, converter, dbAdaptorFactory, 0, null, options);
     }
 
-    public NextFlowCatalogMongoDBIterator(MongoDBIterator<Document> mongoCursor, ClientSession clientSession,
+    public WorkflowCatalogMongoDBIterator(MongoDBIterator<Document> mongoCursor, ClientSession clientSession,
                                           GenericDocumentComplexConverter<E> converter, OrganizationMongoDBAdaptorFactory dbAdaptorFactory,
                                           long studyUid, String user, QueryOptions options) {
         super(mongoCursor, clientSession, converter, null);
@@ -41,7 +41,7 @@ public NextFlowCatalogMongoDBIterator(MongoDBIterator<Document> mongoCursor, Cli
 
         this.options = options;
         this.nextflowListBuffer = new LinkedList<>();
-        this.logger = LoggerFactory.getLogger(NextFlowCatalogMongoDBIterator.class);
+        this.logger = LoggerFactory.getLogger(WorkflowCatalogMongoDBIterator.class);
     }
 
 }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/AbstractManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/AbstractManager.java
index 3d3611c5414..26ebc950048 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/AbstractManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/AbstractManager.java
@@ -30,7 +30,6 @@
 import org.opencb.opencga.catalog.models.InternalGetDataResult;
 import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.config.Configuration;
-import org.opencb.opencga.core.models.IPrivateStudyUid;
 import org.opencb.opencga.core.models.study.Group;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.slf4j.Logger;
@@ -137,6 +136,10 @@ protected InterpretationDBAdaptor getInterpretationDBAdaptor(String organization
         return catalogDBAdaptorFactory.getInterpretationDBAdaptor(organization);
     }
 
+    protected WorkflowDBAdaptor getWorkflowDBAdaptor(String organization) throws CatalogDBException {
+        return catalogDBAdaptorFactory.getWorkflowDBAdaptor(organization);
+    }
+
     protected void fixQueryObject(Query query) {
         changeQueryId(query, ParamConstants.INTERNAL_STATUS_PARAM, "internal.status");
     }
@@ -173,9 +176,8 @@ protected void changeQueryId(Query query, String currentKey, String newKey) {
      * @return the OpenCGAResult with the proper order of results.
      * @throws CatalogException In case of inconsistencies found.
      */
-    <T extends IPrivateStudyUid> InternalGetDataResult<T> keepOriginalOrder(List<String> entries, Function<T, String> getId,
-                                                                            OpenCGAResult<T> queryResult, boolean silent,
-                                                                            boolean keepAllVersions) throws CatalogException {
+    <T> InternalGetDataResult<T> keepOriginalOrder(List<String> entries, Function<T, String> getId, OpenCGAResult<T> queryResult,
+                                                   boolean silent, boolean keepAllVersions) throws CatalogException {
         InternalGetDataResult<T> internalGetDataResult = new InternalGetDataResult<>(queryResult);
 
         Map<String, List<T>> resultMap = new HashMap<>();
@@ -260,8 +262,7 @@ static QueryOptions keepFieldsInQueryOptions(QueryOptions options, List<String>
      * @param <T>             Generic entry (Sample, File, Cohort...)
      * @return a list containing the entries that are in {@code originalEntries} that are not in {@code finalEntries}.
      */
-    <T extends IPrivateStudyUid> List<String> getMissingFields(List<String> originalEntries, List<T> finalEntries,
-                                                               Function<T, String> getId) {
+    <T> List<String> getMissingFields(List<String> originalEntries, List<T> finalEntries, Function<T, String> getId) {
         Set<String> entrySet = new HashSet<>();
         for (T finalEntry : finalEntries) {
             entrySet.add(getId.apply(finalEntry));
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/CatalogManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/CatalogManager.java
index 1409b1e9d4c..9f7b11d0dd3 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/CatalogManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/CatalogManager.java
@@ -89,6 +89,7 @@ public class CatalogManager implements AutoCloseable {
     private ClinicalAnalysisManager clinicalAnalysisManager;
     private InterpretationManager interpretationManager;
     private PanelManager panelManager;
+    private WorkflowManager workflowManager;
 
     private AuditManager auditManager;
     private AuthorizationManager authorizationManager;
@@ -164,6 +165,8 @@ private void configureManagers(Configuration configuration) throws CatalogExcept
         clinicalAnalysisManager = new ClinicalAnalysisManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory,
                 configuration);
         interpretationManager = new InterpretationManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory, configuration);
+        workflowManager = new WorkflowManager(authorizationManager, auditManager, this, catalogDBAdaptorFactory, ioManagerFactory,
+                catalogIOManager, configuration);
     }
 
     private void initializeAdmin(Configuration configuration) throws CatalogDBException {
@@ -451,4 +454,8 @@ public AuditManager getAuditManager() {
     public MigrationManager getMigrationManager() {
         return migrationManager;
     }
+
+    public WorkflowManager getWorkflowManager() {
+        return workflowManager;
+    }
 }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
new file mode 100644
index 00000000000..c9d588bd0b0
--- /dev/null
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -0,0 +1,220 @@
+package org.opencb.opencga.catalog.managers;
+
+import org.opencb.commons.datastore.core.Event;
+import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.commons.datastore.core.Query;
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.commons.utils.ListUtils;
+import org.opencb.opencga.catalog.auth.authorization.AuthorizationManager;
+import org.opencb.opencga.catalog.db.DBAdaptorFactory;
+import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
+import org.opencb.opencga.catalog.exceptions.CatalogException;
+import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
+import org.opencb.opencga.catalog.io.CatalogIOManager;
+import org.opencb.opencga.catalog.io.IOManagerFactory;
+import org.opencb.opencga.catalog.models.InternalGetDataResult;
+import org.opencb.opencga.catalog.utils.Constants;
+import org.opencb.opencga.catalog.utils.ParamUtils;
+import org.opencb.opencga.catalog.utils.UuidUtils;
+import org.opencb.opencga.core.api.ParamConstants;
+import org.opencb.opencga.core.config.Configuration;
+import org.opencb.opencga.core.models.JwtPayload;
+import org.opencb.opencga.core.models.audit.AuditRecord;
+import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.response.OpenCGAResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class WorkflowManager extends AbstractManager {
+
+    private final CatalogIOManager catalogIOManager;
+    private final IOManagerFactory ioManagerFactory;
+
+    private final Logger logger;
+
+    WorkflowManager(AuthorizationManager authorizationManager, AuditManager auditManager, CatalogManager catalogManager,
+                    DBAdaptorFactory catalogDBAdaptorFactory, IOManagerFactory ioManagerFactory, CatalogIOManager catalogIOManager,
+                    Configuration configuration) {
+        super(authorizationManager, auditManager, catalogManager, catalogDBAdaptorFactory, configuration);
+
+        this.catalogIOManager = catalogIOManager;
+        this.ioManagerFactory = ioManagerFactory;
+        this.logger = LoggerFactory.getLogger(WorkflowManager.class);
+    }
+
+
+    private InternalGetDataResult<Workflow> internalGet(String organizationId, List<String> workflowList, Query query, QueryOptions options,
+                                                        String userId, boolean ignoreException) throws CatalogException {
+        if (ListUtils.isEmpty(workflowList)) {
+            throw new CatalogException("Missing workflow entries.");
+        }
+        List<String> uniqueList = ListUtils.unique(workflowList);
+
+        QueryOptions queryOptions = new QueryOptions(ParamUtils.defaultObject(options, QueryOptions::new));
+        Query queryCopy = query == null ? new Query() : new Query(query);
+
+        boolean versioned = queryCopy.getBoolean(Constants.ALL_VERSIONS)
+                || queryCopy.containsKey(WorkflowDBAdaptor.QueryParams.VERSION.key());
+        if (versioned && uniqueList.size() > 1) {
+            throw new CatalogException("Only one workflow allowed when requesting multiple versions");
+        }
+
+        WorkflowDBAdaptor.QueryParams idQueryParam = getFieldFilter(uniqueList);
+        queryCopy.put(idQueryParam.key(), uniqueList);
+
+        // Ensure the field by which we are querying for will be kept in the results
+        queryOptions = keepFieldInQueryOptions(queryOptions, idQueryParam.key());
+
+        OpenCGAResult<Workflow> workflowResult = getWorkflowDBAdaptor(organizationId).get(queryCopy, queryOptions);
+
+        Function<Workflow, String> workflowStringFunction = Workflow::getId;
+        if (idQueryParam.equals(WorkflowDBAdaptor.QueryParams.UUID)) {
+            workflowStringFunction = Workflow::getUuid;
+        }
+
+        if (ignoreException || workflowResult.getNumResults() >= uniqueList.size()) {
+            return keepOriginalOrder(uniqueList, workflowStringFunction, workflowResult, ignoreException, versioned);
+        } else {
+            throw CatalogException.notFound("workflows", getMissingFields(uniqueList, workflowResult.getResults(), workflowStringFunction));
+        }
+    }
+
+    private WorkflowDBAdaptor.QueryParams getFieldFilter(List<String> idList) throws CatalogException {
+        WorkflowDBAdaptor.QueryParams idQueryParam = null;
+        for (String entry : idList) {
+            WorkflowDBAdaptor.QueryParams param = WorkflowDBAdaptor.QueryParams.ID;
+            if (UuidUtils.isOpenCgaUuid(entry)) {
+                param = WorkflowDBAdaptor.QueryParams.UUID;
+            }
+            if (idQueryParam == null) {
+                idQueryParam = param;
+            }
+            if (idQueryParam != param) {
+                throw new CatalogException("Found uuids and ids in the same query. Please, choose one or do two different queries.");
+            }
+        }
+        return idQueryParam;
+    }
+
+    public OpenCGAResult<Workflow> create(Workflow workflow, QueryOptions options, String token) throws CatalogException {
+        options = ParamUtils.defaultObject(options, QueryOptions::new);
+
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        ObjectMap auditParams = new ObjectMap()
+                .append("workflow", workflow)
+                .append("options", options)
+                .append("token", token);
+
+        String organizationId = tokenPayload.getOrganization();
+        String userId = tokenPayload.getUserId(organizationId);
+        try {
+            // 1. Check permissions
+            authorizationManager.checkIsAtLeastOrganizationOwnerOrAdmin(organizationId, userId);
+
+            // 2. Validate the workflow parameters
+            validateNewWorkflow(workflow);
+
+            // 3. We insert the workflow
+            OpenCGAResult<Workflow> insert = getWorkflowDBAdaptor(organizationId).insert(workflow, options);
+            if (options.getBoolean(ParamConstants.INCLUDE_RESULT_PARAM)) {
+                // Fetch created workflow
+                Query query = new Query()
+                        .append(WorkflowDBAdaptor.QueryParams.UID.key(), workflow.getUid());
+                OpenCGAResult<Workflow> result = getWorkflowDBAdaptor(organizationId).get(query, options);
+                insert.setResults(result.getResults());
+            }
+            auditManager.auditCreate(organizationId, userId, Enums.Resource.WORKFLOW, workflow.getId(), workflow.getUuid(), "", "",
+                    auditParams, new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+            return insert;
+        } catch (CatalogException e) {
+            auditManager.auditCreate(organizationId, userId, Enums.Resource.WORKFLOW, workflow.getId(), "", "", "", auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            throw e;
+        }
+    }
+
+    private void validateNewWorkflow(Workflow workflow) throws CatalogParameterException {
+        ParamUtils.checkIdentifier(workflow.getId(), WorkflowDBAdaptor.QueryParams.ID.key());
+        ParamUtils.checkObj(workflow.getType(), WorkflowDBAdaptor.QueryParams.TYPE.key());
+        ParamUtils.checkParameter(workflow.getCommandLine(), WorkflowDBAdaptor.QueryParams.COMMAND_LINE.key());
+        ParamUtils.checkNotEmptyArray(workflow.getScripts(), WorkflowDBAdaptor.QueryParams.SCRIPTS.key());
+        for (Workflow.Script script : workflow.getScripts()) {
+            ParamUtils.checkIdentifier(script.getId(), WorkflowDBAdaptor.QueryParams.SCRIPTS.key() + ".id");
+            ParamUtils.checkParameter(script.getContent(), WorkflowDBAdaptor.QueryParams.SCRIPTS.key() + ".content");
+        }
+        workflow.setUuid(UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.WORKFLOW));
+        workflow.setVersion(1);
+        workflow.setCreationDate(ParamUtils.checkDateOrGetCurrentDate(workflow.getCreationDate(),
+                WorkflowDBAdaptor.QueryParams.CREATION_DATE.key()));
+        workflow.setModificationDate(ParamUtils.checkDateOrGetCurrentDate(workflow.getModificationDate(),
+                WorkflowDBAdaptor.QueryParams.MODIFICATION_DATE.key()));
+    }
+
+    public OpenCGAResult<Workflow> get(String workflow, QueryOptions queryOptions, String token) throws CatalogException {
+        return get(Collections.singletonList(workflow), queryOptions, false, token);
+    }
+
+    public OpenCGAResult<Workflow> get(List<String> workflowList, QueryOptions queryOptions, boolean ignoreException, String token)
+            throws CatalogException {
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        String organizationId = tokenPayload.getOrganization();
+        String userId = tokenPayload.getUserId();
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("workflowList", workflowList)
+                .append("queryOptions", queryOptions)
+                .append("ignoreException", ignoreException)
+                .append("token", token);
+        String operationUuid = UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.AUDIT);
+        auditManager.initAuditBatch(operationUuid);
+        QueryOptions options = queryOptions != null ? new QueryOptions(queryOptions) : new QueryOptions();
+        try {
+            OpenCGAResult<Workflow> result = OpenCGAResult.empty(Workflow.class);
+            options.remove(QueryOptions.LIMIT);
+            InternalGetDataResult<Workflow> responseResult = internalGet(organizationId, workflowList, null, options, userId,
+                    ignoreException);
+
+            Map<String, InternalGetDataResult<Workflow>.Missing> missingMap = new HashMap<>();
+            if (responseResult.getMissing() != null) {
+                missingMap = responseResult.getMissing().stream()
+                        .collect(Collectors.toMap(InternalGetDataResult.Missing::getId, Function.identity()));
+            }
+
+            List<List<Workflow>> versionedResults = responseResult.getVersionedResults();
+            for (int i = 0; i < versionedResults.size(); i++) {
+                String entryId = workflowList.get(i);
+                if (versionedResults.get(i).isEmpty()) {
+                    Event event = new Event(Event.Type.ERROR, entryId, missingMap.get(entryId).getErrorMsg());
+                    // Missing
+                    result.getEvents().add(event);
+                } else {
+                    int size = versionedResults.get(i).size();
+                    result.append(new OpenCGAResult<>(0, Collections.emptyList(), size, versionedResults.get(i), size));
+
+                    Workflow entry = versionedResults.get(i).get(0);
+                    auditManager.auditInfo(organizationId, operationUuid, userId, Enums.Resource.WORKFLOW, entry.getId(), entry.getUuid(),
+                            "", "", auditParams, new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+                }
+            }
+
+            return result;
+        } catch (CatalogException e) {
+            for (String entryId : workflowList) {
+                auditManager.auditInfo(organizationId, operationUuid, userId, Enums.Resource.WORKFLOW, entryId, "", "", "",
+                        auditParams, new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            }
+            throw e;
+        } finally {
+            auditManager.finishAuditBatch(organizationId, operationUuid);
+        }
+    }
+
+}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/UuidUtils.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/UuidUtils.java
index 8fcab95c4d2..ad0b1e4b0d1 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/UuidUtils.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/UuidUtils.java
@@ -50,7 +50,8 @@ public enum Entity {
         PANEL(10),
         INTERPRETATION(11),
         ORGANIZATION(12),
-        NOTES(13);
+        NOTES(13),
+        WORKFLOW(14);
 
         private final int mask;
 
diff --git a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/CatalogManagerExternalResource.java b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/CatalogManagerExternalResource.java
index e8259db2c4b..5080c54f424 100644
--- a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/CatalogManagerExternalResource.java
+++ b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/CatalogManagerExternalResource.java
@@ -39,6 +39,8 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.StandardCopyOption;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 
 /**
  * Created on 05/05/16
@@ -179,4 +181,23 @@ public URI getResourceUri(String resourceName, String targetName) throws IOExcep
         return resourcePath.toUri();
     }
 
+    public String createTmpOutdir() throws IOException {
+        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
+        // stackTrace[0] = "Thread.currentThread"
+        // stackTrace[1] = "newOutputUri"
+        // stackTrace[2] =  caller method
+        String testName = stackTrace[2].getMethodName();
+        return createTmpOutdir(testName);
+    }
+
+    public String createTmpOutdir(String suffix) throws IOException {
+        if (suffix.endsWith("_")) {
+            suffix = suffix.substring(0, suffix.length() - 1);
+        }
+        String folder = "I_tmp_" + new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss.SSS").format(new Date()) + suffix;
+        Path tmpOutDir = Paths.get(getCatalogManager().getConfiguration().getJobDir()).resolve(folder);
+        Files.createDirectories(tmpOutDir);
+        return tmpOutDir.toString();
+    }
+
 }
diff --git a/opencga-client/src/main/R/R/Admin-methods.R b/opencga-client/src/main/R/R/Admin-methods.R
index 5bfb1b049c2..b44096f424d 100644
--- a/opencga-client/src/main/R/R/Admin-methods.R
+++ b/opencga-client/src/main/R/R/Admin-methods.R
@@ -43,7 +43,7 @@ setMethod("adminClient", "OpencgaR", function(OpencgaR, user, endpointName, para
         #' @param count Count the number of elements matching the group.
         #' @param limit Maximum number of documents (groups) to be returned.
         #' @param fields Comma separated list of fields by which to group by.
-        #' @param entity Entity to be grouped by. Allowed values: ['AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL']
+        #' @param entity Entity to be grouped by. Allowed values: ['AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA WORKFLOW FUNCTIONAL']
         #' @param action Action performed.
         #' @param before Object before update.
         #' @param after Object after update.
diff --git a/opencga-client/src/main/R/R/Study-methods.R b/opencga-client/src/main/R/R/Study-methods.R
index ba022ea666e..ba5ba51c6c3 100644
--- a/opencga-client/src/main/R/R/Study-methods.R
+++ b/opencga-client/src/main/R/R/Study-methods.R
@@ -118,7 +118,7 @@ setMethod("studyClient", "OpencgaR", function(OpencgaR, group, id, members, stud
         #' @param operationId Audit operation UUID.
         #' @param userId User ID.
         #' @param action Action performed by the user.
-        #' @param resource Resource involved. Allowed values: ['AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL']
+        #' @param resource Resource involved. Allowed values: ['AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA WORKFLOW FUNCTIONAL']
         #' @param resourceId Resource ID.
         #' @param resourceUuid resource UUID.
         #' @param status Filter by status. Allowed values: ['SUCCESS ERROR']
diff --git a/opencga-client/src/main/javascript/Admin.js b/opencga-client/src/main/javascript/Admin.js
index 5538e904dfc..b096169fe0e 100644
--- a/opencga-client/src/main/javascript/Admin.js
+++ b/opencga-client/src/main/javascript/Admin.js
@@ -37,7 +37,7 @@ export default class Admin extends OpenCGAParentClass {
     /** Group by operation
     * @param {String} fields - Comma separated list of fields by which to group by.
     * @param {"AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS
-    *     INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL"} entity - Entity to be grouped by.
+    *     INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA WORKFLOW FUNCTIONAL"} entity - Entity to be grouped by.
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {Boolean} [params.count] - Count the number of elements matching the group.
     * @param {Number} [params.limit = "50"] - Maximum number of documents (groups) to be returned. The default value is 50.
diff --git a/opencga-client/src/main/javascript/Study.js b/opencga-client/src/main/javascript/Study.js
index 2c2b6abf793..d6eead290d4 100644
--- a/opencga-client/src/main/javascript/Study.js
+++ b/opencga-client/src/main/javascript/Study.js
@@ -119,7 +119,7 @@ export default class Study extends OpenCGAParentClass {
     * @param {String} [params.userId] - User ID.
     * @param {String} [params.action] - Action performed by the user.
     * @param {"AUDIT NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS
-    *     INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL"} [params.resource] - Resource involved.
+    *     INTERPRETATION VARIANT ALIGNMENT CLINICAL EXPRESSION RGA WORKFLOW FUNCTIONAL"} [params.resource] - Resource involved.
     * @param {String} [params.resourceId] - Resource ID.
     * @param {String} [params.resourceUuid] - resource UUID.
     * @param {"SUCCESS ERROR"} [params.status] - Filter by status.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/admin_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/admin_client.py
index 9702e5d6463..7169a5a04c8 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/admin_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/admin_client.py
@@ -27,7 +27,7 @@ def group_by_audit(self, fields, entity, **options):
         :param str entity: Entity to be grouped by. Allowed values: ['AUDIT
             NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL
             COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION
-            VARIANT ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL']
+            VARIANT ALIGNMENT CLINICAL EXPRESSION RGA WORKFLOW FUNCTIONAL']
             (REQUIRED)
         :param str fields: Comma separated list of fields by which to group
             by. (REQUIRED)
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/study_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/study_client.py
index 639f20c6b53..b399d3b0529 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/study_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/study_client.py
@@ -139,7 +139,7 @@ def search_audit(self, study, **options):
         :param str resource: Resource involved. Allowed values: ['AUDIT NOTE
             ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL COHORT
             DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION VARIANT
-            ALIGNMENT CLINICAL EXPRESSION RGA NEXTFLOW FUNCTIONAL']
+            ALIGNMENT CLINICAL EXPRESSION RGA WORKFLOW FUNCTIONAL']
         :param str resource_id: Resource ID.
         :param str resource_uuid: resource UUID.
         :param str status: Filter by status. Allowed values: ['SUCCESS ERROR']
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/common/Enums.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/common/Enums.java
index 04981030ebc..b82f7669af2 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/common/Enums.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/common/Enums.java
@@ -79,7 +79,7 @@ public enum Resource {
         CLINICAL,
         EXPRESSION,
         RGA,
-        NEXTFLOW,
+        WORKFLOW,
         FUNCTIONAL;
 
         public List<String> getFullPermissionList() {
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlow.java
deleted file mode 100644
index af4a527ef1d..00000000000
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlow.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package org.opencb.opencga.core.models.nextflow;
-
-public class NextFlow {
-
-    private String id;
-    private int version;
-    private String script;
-
-    public NextFlow() {
-    }
-
-    public NextFlow(String id, int version, String script) {
-        this.id = id;
-        this.version = version;
-        this.script = script;
-    }
-
-    @Override
-    public String toString() {
-        final StringBuilder sb = new StringBuilder("NextFlow{");
-        sb.append("id='").append(id).append('\'');
-        sb.append(", version=").append(version);
-        sb.append(", script='").append(script).append('\'');
-        sb.append('}');
-        return sb.toString();
-    }
-
-    public String getId() {
-        return id;
-    }
-
-    public NextFlow setId(String id) {
-        this.id = id;
-        return this;
-    }
-
-    public int getVersion() {
-        return version;
-    }
-
-    public NextFlow setVersion(int version) {
-        this.version = version;
-        return this;
-    }
-
-    public String getScript() {
-        return script;
-    }
-
-    public NextFlow setScript(String script) {
-        this.script = script;
-        return this;
-    }
-}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/Workflow.java
new file mode 100644
index 00000000000..726cfeebe00
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/Workflow.java
@@ -0,0 +1,165 @@
+package org.opencb.opencga.core.models.nextflow;
+
+import org.opencb.opencga.core.models.PrivateFields;
+
+import java.util.List;
+
+public class Workflow extends PrivateFields {
+
+    private String id;
+    private String uuid;
+    private int version;
+    private Type type;
+    private String commandLine;
+    private List<Script> scripts;
+
+    private String creationDate;
+    private String modificationDate;
+
+    public enum Type {
+        NEXTFLOW
+    }
+
+    public Workflow() {
+    }
+
+    public Workflow(String id, int version, Type type, String commandLine, List<Script> scripts, String creationDate,
+                    String modificationDate) {
+        this.id = id;
+        this.version = version;
+        this.type = type;
+        this.commandLine = commandLine;
+        this.scripts = scripts;
+        this.creationDate = creationDate;
+        this.modificationDate = modificationDate;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("Workflow{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", uuid='").append(uuid).append('\'');
+        sb.append(", version=").append(version);
+        sb.append(", type=").append(type);
+        sb.append(", commandLine='").append(commandLine).append('\'');
+        sb.append(", scripts=").append(scripts);
+        sb.append(", creationDate='").append(creationDate).append('\'');
+        sb.append(", modificationDate='").append(modificationDate).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public Workflow setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getUuid() {
+        return uuid;
+    }
+
+    public Workflow setUuid(String uuid) {
+        this.uuid = uuid;
+        return this;
+    }
+
+    public int getVersion() {
+        return version;
+    }
+
+    public Workflow setVersion(int version) {
+        this.version = version;
+        return this;
+    }
+
+    public Type getType() {
+        return type;
+    }
+
+    public Workflow setType(Type type) {
+        this.type = type;
+        return this;
+    }
+
+    public String getCommandLine() {
+        return commandLine;
+    }
+
+    public Workflow setCommandLine(String commandLine) {
+        this.commandLine = commandLine;
+        return this;
+    }
+
+    public List<Script> getScripts() {
+        return scripts;
+    }
+
+    public Workflow setScripts(List<Script> scripts) {
+        this.scripts = scripts;
+        return this;
+    }
+
+    public String getCreationDate() {
+        return creationDate;
+    }
+
+    public Workflow setCreationDate(String creationDate) {
+        this.creationDate = creationDate;
+        return this;
+    }
+
+    public String getModificationDate() {
+        return modificationDate;
+    }
+
+    public Workflow setModificationDate(String modificationDate) {
+        this.modificationDate = modificationDate;
+        return this;
+    }
+
+    public static class Script {
+
+        private String id;
+        private String content;
+
+        public Script() {
+        }
+
+        public Script(String id, String content) {
+            this.id = id;
+            this.content = content;
+        }
+
+        @Override
+        public String toString() {
+            final StringBuilder sb = new StringBuilder("Script{");
+            sb.append("id='").append(id).append('\'');
+            sb.append(", content='").append(content).append('\'');
+            sb.append('}');
+            return sb.toString();
+        }
+
+        public String getId() {
+            return id;
+        }
+
+        public Script setId(String id) {
+            this.id = id;
+            return this;
+        }
+
+        public String getContent() {
+            return content;
+        }
+
+        public Script setContent(String content) {
+            this.content = content;
+            return this;
+        }
+    }
+
+}

From 74f11d6757b5c7939a923bdcea87911d1db9ead2 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 5 Aug 2024 09:50:33 +0200
Subject: [PATCH 03/99] analysis: add test to run nextflow docker, #TASK-6445

---
 .../analysis/tools/NextFlowExecutor.java      | 12 ++++------
 .../analysis/tools/WorkflowExecutorTest.java  | 24 ++++++++++++++++++-
 .../catalog/managers/WorkflowManager.java     |  2 +-
 3 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
index 667356af04e..c179242d714 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
@@ -43,7 +43,7 @@ public class NextFlowExecutor extends OpenCgaTool {
     public static final String DESCRIPTION = "Execute a Nextflow analysis.";
 
     @ToolParams
-    protected NextFlowRunParams toolParams = new NextFlowRunParams();
+    protected NextFlowRunParams nextflowParams = new NextFlowRunParams();
 
     private Workflow workflow;
 
@@ -56,18 +56,18 @@ public class NextFlowExecutor extends OpenCgaTool {
     protected void check() throws Exception {
         super.check();
 
-        if (toolParams.getId() == null) {
+        if (nextflowParams.getId() == null) {
             throw new IllegalArgumentException("Missing Nextflow ID");
         }
 
-        OpenCGAResult<Workflow> result = catalogManager.getWorkflowManager().get(toolParams.getId(), QueryOptions.empty(), token);
+        OpenCGAResult<Workflow> result = catalogManager.getWorkflowManager().get(nextflowParams.getId(), QueryOptions.empty(), token);
         if (result.getNumResults() == 0) {
-            throw new ToolException("Workflow '" + toolParams.getId() + "' not found");
+            throw new ToolException("Workflow '" + nextflowParams.getId() + "' not found");
         }
         workflow = result.first();
 
         if (workflow == null) {
-            throw new ToolException("Workflow '" + toolParams.getId() + "' is null");
+            throw new ToolException("Workflow '" + nextflowParams.getId() + "' is null");
         }
     }
 
@@ -92,8 +92,6 @@ protected void run() throws Exception {
         StringBuilder stringBuilder = new StringBuilder()
                 .append("nextflow -c ").append(workingDirectory).append("/nextflow.config")
                 .append(" ").append(workflow.getCommandLine())
-//                .append(" run nextflow-io/rnaseq-nf -with-docker")
-//                .append(" run ").append(workingDirectory).append("/pipeline.nf")
                 .append(" -with-report ").append(workingDirectory).append("/report.html");
         List<String> cliArgs = Arrays.asList(StringUtils.split(stringBuilder.toString(), " "));
 
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index a54543cfc88..c9b42d8c78a 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -22,7 +22,7 @@
 public class WorkflowExecutorTest extends AbstractManagerTest {
 
     @Test
-    public void myTest() throws ToolException, CatalogException, IOException {
+    public void nextflowScriptTest() throws ToolException, CatalogException, IOException {
         InputStream inputStream = StorageManager.class.getClassLoader().getResourceAsStream("storage-configuration.yml");
         StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
 
@@ -41,6 +41,28 @@ public void myTest() throws ToolException, CatalogException, IOException {
         System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
     }
 
+    @Test
+    public void nextflowDockerTest() throws ToolException, CatalogException, IOException {
+        InputStream inputStream = StorageManager.class.getClassLoader().getResourceAsStream("storage-configuration.yml");
+        StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
+        Workflow workflow = new Workflow()
+                .setId("workflow")
+                .setCommandLine("run nextflow-io/rnaseq-nf -with-docker")
+                .setType(Workflow.Type.NEXTFLOW);
+        catalogManager.getWorkflowManager().create(workflow, QueryOptions.empty(), ownerToken);
+
+        Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
+
+        StopWatch stopWatch = StopWatch.createStarted();
+        NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
+        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1);
+        nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), catalogManager,
+                StorageEngineFactory.get(storageConfiguration), runParams.toObjectMap(), outDir, "", false, ownerToken);
+        nextFlowExecutorTest.start();
+        System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
+    }
+
+
     private Workflow getDummyWorkflow() {
         String scriptContent = "params.str = 'Hello world!'\n" +
                 "\n" +
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index c9d588bd0b0..81c22b0bde7 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -145,7 +145,7 @@ private void validateNewWorkflow(Workflow workflow) throws CatalogParameterExcep
         ParamUtils.checkIdentifier(workflow.getId(), WorkflowDBAdaptor.QueryParams.ID.key());
         ParamUtils.checkObj(workflow.getType(), WorkflowDBAdaptor.QueryParams.TYPE.key());
         ParamUtils.checkParameter(workflow.getCommandLine(), WorkflowDBAdaptor.QueryParams.COMMAND_LINE.key());
-        ParamUtils.checkNotEmptyArray(workflow.getScripts(), WorkflowDBAdaptor.QueryParams.SCRIPTS.key());
+        workflow.setScripts(workflow.getScripts() != null ? workflow.getScripts() : Collections.emptyList());
         for (Workflow.Script script : workflow.getScripts()) {
             ParamUtils.checkIdentifier(script.getId(), WorkflowDBAdaptor.QueryParams.SCRIPTS.key() + ".id");
             ParamUtils.checkParameter(script.getContent(), WorkflowDBAdaptor.QueryParams.SCRIPTS.key() + ".content");

From c97f75e5761ad4ff452f300dde1e04a404d609ba Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 5 Aug 2024 12:35:04 +0200
Subject: [PATCH 04/99] app: add nextflow to opencga-base, #TASK-6445

---
 opencga-app/app/cloud/docker/opencga-base/Dockerfile | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/opencga-app/app/cloud/docker/opencga-base/Dockerfile b/opencga-app/app/cloud/docker/opencga-base/Dockerfile
index b6f334f9d8a..e488f4fb50b 100644
--- a/opencga-app/app/cloud/docker/opencga-base/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-base/Dockerfile
@@ -1,6 +1,6 @@
 ## Based on Ubuntu 22.04 (jammy)
 ## We are now using OpenJDK 8u372 to support "cgroup v2", see https://developers.redhat.com/articles/2023/04/19/openjdk-8u372-feature-cgroup-v2-support#
-FROM eclipse-temurin:8u372-b07-jre-jammy
+FROM eclipse-temurin:11.0.23_9-jre-jammy
 
 ARG BUILD_PATH="."
 
@@ -21,6 +21,10 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpa
     ## Install yq
     wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && \
     chmod +x /usr/local/bin/yq && \
+    ## Install Nextflow \
+    curl -s https://get.nextflow.io | bash && \
+    chmod +xr nextflow && \
+    mv nextflow /usr/local/bin/ && \
     ## Clean downloaded packages to make images smaller
     rm -rf /var/lib/apt/lists/* && \
     adduser --disabled-password --uid 1001 opencga

From d77609256dde01959fbf73e938be21ca20f35dae Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 7 Aug 2024 09:38:02 +0200
Subject: [PATCH 05/99] catalog: add new update operation, #TASK-6445

---
 .../analysis/tools/NextFlowExecutor.java      |   4 +-
 .../analysis/tools/WorkflowExecutorTest.java  |  18 ++-
 .../app/cloud/docker/opencga-base/Dockerfile  |   2 +-
 .../catalog/db/api/WorkflowDBAdaptor.java     |   4 +-
 .../SnapshotVersionedMongoDBAdaptor.java      |   4 +
 .../db/mongodb/WorkflowMongoDBAdaptor.java    | 125 +++++++++++++++--
 .../mongodb/converters/WorkflowConverter.java |   2 +-
 .../catalog/managers/WorkflowManager.java     |  76 +++++++++-
 .../src/main/resources/catalog-indexes.txt    |   9 +-
 .../opencga/core/api/FieldConstants.java      |  13 ++
 .../NextFlowRunParams.java                    |   2 +-
 .../{nextflow => workflow}/Workflow.java      |  54 +++++++-
 .../models/workflow/WorkflowCreateParams.java | 130 ++++++++++++++++++
 .../models/workflow/WorkflowUpdateParams.java | 108 +++++++++++++++
 14 files changed, 515 insertions(+), 36 deletions(-)
 rename opencga-core/src/main/java/org/opencb/opencga/core/models/{nextflow => workflow}/NextFlowRunParams.java (95%)
 rename opencga-core/src/main/java/org/opencb/opencga/core/models/{nextflow => workflow}/Workflow.java (62%)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
index c179242d714..caf4b065117 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
@@ -11,8 +11,8 @@
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
-import org.opencb.opencga.core.models.nextflow.NextFlowRunParams;
-import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
+import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index c9b42d8c78a..c80d59681fe 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -8,8 +8,9 @@
 import org.opencb.opencga.catalog.managers.AbstractManagerTest;
 import org.opencb.opencga.core.config.storage.StorageConfiguration;
 import org.opencb.opencga.core.exceptions.ToolException;
-import org.opencb.opencga.core.models.nextflow.NextFlowRunParams;
-import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
+import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
 import org.opencb.opencga.storage.core.StorageEngineFactory;
 
 import java.io.IOException;
@@ -26,7 +27,7 @@ public void nextflowScriptTest() throws ToolException, CatalogException, IOExcep
         InputStream inputStream = StorageManager.class.getClassLoader().getResourceAsStream("storage-configuration.yml");
         StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
 
-        Workflow workflow = getDummyWorkflow();
+        WorkflowCreateParams workflow = createDummyWorkflow();
         catalogManager.getWorkflowManager().create(workflow, QueryOptions.empty(), ownerToken);
 
         Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
@@ -45,10 +46,9 @@ public void nextflowScriptTest() throws ToolException, CatalogException, IOExcep
     public void nextflowDockerTest() throws ToolException, CatalogException, IOException {
         InputStream inputStream = StorageManager.class.getClassLoader().getResourceAsStream("storage-configuration.yml");
         StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
-        Workflow workflow = new Workflow()
+        WorkflowCreateParams workflow = new WorkflowCreateParams()
                 .setId("workflow")
-                .setCommandLine("run nextflow-io/rnaseq-nf -with-docker")
-                .setType(Workflow.Type.NEXTFLOW);
+                .setCommandLine("run nextflow-io/rnaseq-nf -with-docker");
         catalogManager.getWorkflowManager().create(workflow, QueryOptions.empty(), ownerToken);
 
         Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
@@ -62,8 +62,7 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
     }
 
-
-    private Workflow getDummyWorkflow() {
+    private WorkflowCreateParams createDummyWorkflow() {
         String scriptContent = "params.str = 'Hello world!'\n" +
                 "\n" +
                 "process splitLetters {\n" +
@@ -99,10 +98,9 @@ private Workflow getDummyWorkflow() {
                 "workflow {\n" +
                 "    splitLetters | flatten | convertToUpper | view { it.trim() } | sleep\n" +
                 "}";
-        return new Workflow()
+        return new WorkflowCreateParams()
                 .setId("workflow")
                 .setCommandLine("run pipeline.nf")
-                .setType(Workflow.Type.NEXTFLOW)
                 .setScripts(Collections.singletonList(new Workflow.Script("pipeline.nf", scriptContent)));
     }
 }
diff --git a/opencga-app/app/cloud/docker/opencga-base/Dockerfile b/opencga-app/app/cloud/docker/opencga-base/Dockerfile
index e488f4fb50b..35b25be2b02 100644
--- a/opencga-app/app/cloud/docker/opencga-base/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-base/Dockerfile
@@ -1,6 +1,6 @@
 ## Based on Ubuntu 22.04 (jammy)
 ## We are now using OpenJDK 8u372 to support "cgroup v2", see https://developers.redhat.com/articles/2023/04/19/openjdk-8u372-feature-cgroup-v2-support#
-FROM eclipse-temurin:11.0.23_9-jre-jammy
+FROM eclipse-temurin:11.0.24_8-jre-noble
 
 ARG BUILD_PATH="."
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
index cc9ebc9e96a..fddf1dd5898 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
@@ -6,7 +6,7 @@
 import org.opencb.opencga.catalog.exceptions.CatalogAuthorizationException;
 import org.opencb.opencga.catalog.exceptions.CatalogDBException;
 import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
-import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.response.OpenCGAResult;
 
 import java.util.Map;
@@ -22,6 +22,7 @@ enum QueryParams implements QueryParam {
         ID("id", TEXT, ""),
         UID("uid", LONG, ""),
         UUID("uuid", TEXT, ""),
+        DESCRIPTION("description", TEXT, ""),
         TYPE("type", TEXT, ""),
         COMMAND_LINE("commandLine", TEXT, ""),
         SCRIPTS("scripts", OBJECT, ""),
@@ -30,6 +31,7 @@ enum QueryParams implements QueryParam {
         VERSION("version", INTEGER, ""), // Version of the sample
         CREATION_DATE("creationDate", DATE, ""),
         MODIFICATION_DATE("modificationDate", DATE, ""),
+        ATTRIBUTES("attributes", OBJECT, ""),
         STUDY_UID("studyUid", INTEGER_ARRAY, ""),
         STUDY("study", INTEGER_ARRAY, ""); // Alias to studyId in the database. Only for the webservices.
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
index 1c782686bf7..8a4ac1ed734 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
@@ -218,6 +218,10 @@ protected <E> OpenCGAResult<E> update(ClientSession session, Bson sourceQuery, L
             }
         }
 
+        if (entryList.isEmpty()) {
+            throw new CatalogDBException("No documents could be found to be updated");
+        }
+
         // 2. Execute main update
         OpenCGAResult<E> executionResult = update.execute(entryList);
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index 809550306c0..0b62903cf8f 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -6,10 +6,7 @@
 import org.apache.commons.lang3.time.StopWatch;
 import org.bson.Document;
 import org.bson.conversions.Bson;
-import org.opencb.commons.datastore.core.DataResult;
-import org.opencb.commons.datastore.core.ObjectMap;
-import org.opencb.commons.datastore.core.Query;
-import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.commons.datastore.core.*;
 import org.opencb.commons.datastore.mongodb.MongoDBCollection;
 import org.opencb.commons.datastore.mongodb.MongoDBIterator;
 import org.opencb.opencga.catalog.db.api.DBIterator;
@@ -20,17 +17,20 @@
 import org.opencb.opencga.catalog.exceptions.CatalogDBException;
 import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
 import org.opencb.opencga.catalog.utils.Constants;
+import org.opencb.opencga.catalog.utils.ParamUtils;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Configuration;
-import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.slf4j.LoggerFactory;
 
 import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
+import java.util.stream.Collectors;
 
-import static org.opencb.opencga.catalog.db.mongodb.MongoDBUtils.fixAclProjection;
+import static org.opencb.opencga.catalog.db.api.ClinicalAnalysisDBAdaptor.QueryParams.MODIFICATION_DATE;
+import static org.opencb.opencga.catalog.db.mongodb.MongoDBUtils.*;
 
 public class WorkflowMongoDBAdaptor extends CatalogMongoDBAdaptor implements WorkflowDBAdaptor {
 
@@ -231,15 +231,121 @@ public OpenCGAResult<Workflow> stats(Query query) {
     }
 
     @Override
-    public OpenCGAResult<Workflow> update(long id, ObjectMap parameters, QueryOptions queryOptions)
+    public OpenCGAResult<Workflow> update(long uid, ObjectMap parameters, QueryOptions queryOptions)
             throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
+        Query query = new Query(QueryParams.UID.key(), uid);
+        return update(query, parameters, queryOptions);
     }
 
     @Override
     public OpenCGAResult<Workflow> update(Query query, ObjectMap parameters, QueryOptions queryOptions)
             throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
+        try {
+            return runTransaction(clientSession -> privateUpdate(clientSession, query, parameters, queryOptions));
+        } catch (CatalogDBException e) {
+            logger.error("Could not update workflows for query {}", query.toJson(), e);
+            throw new CatalogDBException("Could not update workflows based on query " + query.toJson(), e);
+        }
+    }
+
+    OpenCGAResult<Workflow> privateUpdate(ClientSession clientSession, Query query, ObjectMap parameters, QueryOptions queryOptions)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        long tmpStartTime = startQuery();
+        Bson bsonQuery = parseQuery(query);
+        return versionedMongoDBAdaptor.update(clientSession, bsonQuery, (entrylist) -> {
+            String workflowIds = entrylist.stream().map(w -> w.getString(QueryParams.ID.key())).collect(Collectors.joining(", "));
+
+            UpdateDocument updateParams = parseAndValidateUpdateParams(parameters, queryOptions);
+            Document workflowUpdate = updateParams.toFinalUpdateDocument();
+
+            if (workflowUpdate.isEmpty()) {
+                if (!parameters.isEmpty()) {
+                    logger.error("Non-processed update parameters: {}", parameters.keySet());
+                }
+                throw new CatalogDBException("Nothing to be updated");
+            }
+
+            List<Event> events = new ArrayList<>();
+
+            logger.debug("Workflow update: query : {}, update: {}", bsonQuery.toBsonDocument(), workflowUpdate.toBsonDocument());
+            DataResult<?> result = workflowCollection.update(clientSession, bsonQuery, workflowUpdate,
+                    new QueryOptions(MongoDBCollection.MULTI, true));
+
+            if (result.getNumMatches() == 0) {
+                throw new CatalogDBException("Workflow(s) '" + workflowIds + "' not found");
+            }
+            if (result.getNumUpdated() == 0) {
+                events.add(new Event(Event.Type.WARNING, workflowIds, "Workflow(s) already updated"));
+            }
+            logger.debug("Workflow(s) '{}' successfully updated", workflowIds);
+
+
+            return endWrite(tmpStartTime, result.getNumMatches(), result.getNumUpdated(), events);
+        }, null, null);
+    }
+
+    private UpdateDocument parseAndValidateUpdateParams(ObjectMap parameters, QueryOptions queryOptions) throws CatalogDBException {
+        if (parameters.containsKey(QueryParams.ID.key())) {
+            throw new CatalogDBException("It is not allowed to update the 'id' of a workflow");
+        }
+
+        UpdateDocument document = new UpdateDocument();
+
+        if (StringUtils.isNotEmpty(parameters.getString(QueryParams.CREATION_DATE.key()))) {
+            String time = parameters.getString(QueryParams.CREATION_DATE.key());
+            Date date = TimeUtils.toDate(time);
+            document.getSet().put(QueryParams.CREATION_DATE.key(), time);
+            document.getSet().put(PRIVATE_CREATION_DATE, date);
+        }
+        if (StringUtils.isNotEmpty(parameters.getString(MODIFICATION_DATE.key()))) {
+            String time = parameters.getString(QueryParams.MODIFICATION_DATE.key());
+            Date date = TimeUtils.toDate(time);
+            document.getSet().put(QueryParams.MODIFICATION_DATE.key(), time);
+            document.getSet().put(PRIVATE_MODIFICATION_DATE, date);
+        }
+
+        final String[] acceptedParams = {QueryParams.DESCRIPTION.key(), QueryParams.COMMAND_LINE.key()};
+        filterStringParams(parameters, document.getSet(), acceptedParams);
+
+        final String[] acceptedMapParams = {QueryParams.ATTRIBUTES.key()};
+        filterMapParams(parameters, document.getSet(), acceptedMapParams);
+
+        // Check if the tags exist.
+        if (parameters.containsKey(QueryParams.SCRIPTS.key())) {
+            List<Workflow.Script> scriptList = parameters.getAsList(QueryParams.SCRIPTS.key(), Workflow.Script.class);
+
+            if (!scriptList.isEmpty()) {
+                Map<String, Object> actionMap = queryOptions.getMap(Constants.ACTIONS, new HashMap<>());
+                ParamUtils.BasicUpdateAction operation =
+                        ParamUtils.BasicUpdateAction.from(actionMap, QueryParams.SCRIPTS.key(), ParamUtils.BasicUpdateAction.ADD);
+                switch (operation) {
+                    case SET:
+                        document.getSet().put(QueryParams.SCRIPTS.key(), scriptList);
+                        break;
+                    case REMOVE:
+                        document.getPullAll().put(QueryParams.SCRIPTS.key(), scriptList);
+                        break;
+                    case ADD:
+                        document.getAddToSet().put(QueryParams.SCRIPTS.key(), scriptList);
+                        break;
+                    default:
+                        throw new IllegalArgumentException("Unknown update action " + operation);
+                }
+            }
+        }
+
+        if (!document.toFinalUpdateDocument().isEmpty()) {
+            String time = TimeUtils.getTime();
+            if (StringUtils.isEmpty(parameters.getString(QueryParams.MODIFICATION_DATE.key()))) {
+                // Update modificationDate param
+                Date date = TimeUtils.toDate(time);
+                document.getSet().put(QueryParams.MODIFICATION_DATE.key(), time);
+                document.getSet().put(PRIVATE_MODIFICATION_DATE, date);
+            }
+            document.getSet().put(INTERNAL_LAST_MODIFIED, time);
+        }
+
+        return document;
     }
 
     @Override
@@ -355,6 +461,7 @@ private Bson parseQuery(Query query, String user) throws CatalogDBException, Cat
                     case UUID:
                     case RELEASE:
                     case VERSION:
+                    case TYPE:
                         addAutoOrQuery(queryParam.key(), queryParam.key(), queryCopy, queryParam.type(), andBsonList);
                         break;
                     default:
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
index 589220cacaa..5fda14d7e78 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
@@ -1,6 +1,6 @@
 package org.opencb.opencga.catalog.db.mongodb.converters;
 
-import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.models.workflow.Workflow;
 
 public class WorkflowConverter extends OpenCgaMongoConverter<Workflow> {
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 81c22b0bde7..2c0886fa80b 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -1,5 +1,6 @@
 package org.opencb.opencga.catalog.managers;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import org.opencb.commons.datastore.core.Event;
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.Query;
@@ -21,20 +22,25 @@
 import org.opencb.opencga.core.models.JwtPayload;
 import org.opencb.opencga.core.models.audit.AuditRecord;
 import org.opencb.opencga.core.models.common.Enums;
-import org.opencb.opencga.core.models.nextflow.Workflow;
+import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
+import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import static org.opencb.opencga.core.common.JacksonUtils.getUpdateObjectMapper;
+
 public class WorkflowManager extends AbstractManager {
 
+    public static final QueryOptions INCLUDE_WORKFLOW_IDS = new QueryOptions(QueryOptions.INCLUDE, Arrays.asList(
+            WorkflowDBAdaptor.QueryParams.ID.key(), WorkflowDBAdaptor.QueryParams.UID.key(), WorkflowDBAdaptor.QueryParams.UUID.key(),
+            WorkflowDBAdaptor.QueryParams.VERSION.key()));
+
     private final CatalogIOManager catalogIOManager;
     private final IOManagerFactory ioManagerFactory;
 
@@ -104,17 +110,20 @@ private WorkflowDBAdaptor.QueryParams getFieldFilter(List<String> idList) throws
         return idQueryParam;
     }
 
-    public OpenCGAResult<Workflow> create(Workflow workflow, QueryOptions options, String token) throws CatalogException {
+    public OpenCGAResult<Workflow> create(WorkflowCreateParams createParams, QueryOptions options, String token) throws CatalogException {
         options = ParamUtils.defaultObject(options, QueryOptions::new);
 
         JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
         ObjectMap auditParams = new ObjectMap()
-                .append("workflow", workflow)
+                .append("workflow", createParams)
                 .append("options", options)
                 .append("token", token);
 
         String organizationId = tokenPayload.getOrganization();
         String userId = tokenPayload.getUserId(organizationId);
+
+        // 0. Create the workflow object
+        Workflow workflow = createParams.toWorkflow();
         try {
             // 1. Check permissions
             authorizationManager.checkIsAtLeastOrganizationOwnerOrAdmin(organizationId, userId);
@@ -158,6 +167,59 @@ private void validateNewWorkflow(Workflow workflow) throws CatalogParameterExcep
                 WorkflowDBAdaptor.QueryParams.MODIFICATION_DATE.key()));
     }
 
+    public OpenCGAResult<Workflow> update(String workflowId, WorkflowUpdateParams updateParams, QueryOptions options, String token)
+            throws CatalogException {
+        options = ParamUtils.defaultObject(options, QueryOptions::new);
+
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        ObjectMap updateMap = null;
+        try {
+            if (updateParams != null) {
+                updateMap = new ObjectMap(getUpdateObjectMapper().writeValueAsString(this));
+            }
+        } catch (JsonProcessingException e) {
+            throw new CatalogException("Could not parse WorkflowUpdateParams object: " + e.getMessage(), e);
+        }
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("workflowId", workflowId)
+                .append("updateParams", updateMap)
+                .append("options", options)
+                .append("token", token);
+
+        String organizationId = tokenPayload.getOrganization();
+        String userId = tokenPayload.getUserId(organizationId);
+
+        String id = UuidUtils.isOpenCgaUuid(workflowId) ? "" : workflowId;
+        String uuid = UuidUtils.isOpenCgaUuid(workflowId) ? workflowId : "";
+        try {
+            // 1. Check permissions
+            authorizationManager.checkIsAtLeastOrganizationOwnerOrAdmin(organizationId, userId);
+
+            Workflow workflow = internalGet(organizationId, Collections.singletonList(workflowId), null, INCLUDE_WORKFLOW_IDS, userId,
+                    false).first();
+            id = workflow.getId();
+            uuid = workflow.getUuid();
+
+            // 2. Update workflow object
+            OpenCGAResult<Workflow> insert = getWorkflowDBAdaptor(organizationId).update(workflow.getUid(), updateMap, options);
+            if (options.getBoolean(ParamConstants.INCLUDE_RESULT_PARAM)) {
+                // Fetch updated workflow
+                Query query = new Query()
+                        .append(WorkflowDBAdaptor.QueryParams.UID.key(), workflow.getUid());
+                OpenCGAResult<Workflow> result = getWorkflowDBAdaptor(organizationId).get(query, options);
+                insert.setResults(result.getResults());
+            }
+            auditManager.auditUpdate(organizationId, userId, Enums.Resource.WORKFLOW, id, uuid, "", "", auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+            return insert;
+        } catch (CatalogException e) {
+            auditManager.auditUpdate(organizationId, userId, Enums.Resource.WORKFLOW, id, uuid, "", "", auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            throw e;
+        }
+    }
+
     public OpenCGAResult<Workflow> get(String workflow, QueryOptions queryOptions, String token) throws CatalogException {
         return get(Collections.singletonList(workflow), queryOptions, false, token);
     }
diff --git a/opencga-catalog/src/main/resources/catalog-indexes.txt b/opencga-catalog/src/main/resources/catalog-indexes.txt
index 557a660716a..e27276e6ab8 100644
--- a/opencga-catalog/src/main/resources/catalog-indexes.txt
+++ b/opencga-catalog/src/main/resources/catalog-indexes.txt
@@ -259,4 +259,11 @@
 {"collections": ["audit"], "fields": {"resourceId": 1, "studyUuid": 1}, "options": {}}
 {"collections": ["audit"], "fields": {"resourceUuid": 1, "studyUuid": 1}, "options": {}}
 {"collections": ["audit"], "fields": {"status.name": 1, "studyUuid": 1}, "options": {}}
-{"collections": ["audit"], "fields": {"date": 1, "studyUuid": 1}, "options": {}}
\ No newline at end of file
+{"collections": ["audit"], "fields": {"date": 1, "studyUuid": 1}, "options": {}}
+
+{"collections": ["workflow", "workflow_archive"], "fields": {"uid": 1, "version": 1}, "options": {"unique": true}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"id": 1, "version": 1}, "options": {"unique": true}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"uuid": 1, "version": 1}, "options": {"unique": true}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"type": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"_creationDate": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"_modificationDate": 1}, "options": {}}
\ No newline at end of file
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index 835f89a61a6..03e1d83125c 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -306,6 +306,19 @@ public class FieldConstants {
             + "STUDY, FILE, SAMPLE, JOB, INDIVIDUAL, COHORT, DISEASE_PANEL, FAMILY, CLINICAL_ANALYSIS, INTERPRETATION, "
             + "VARIANT, ALIGNMENT, CLINICAL, EXPRESSION, RGA and FUNCTIONAL.";
 
+    // Workflow
+    //Sample
+    public static final String WORKFLOW_ID_DESCRIPTION = "Workflow ID.";
+    public static final String WORKFLOW_TYPE_DESCRIPTION = "Workflow type. Valid values: NEXTFLOW.";
+    public static final String WORKFLOW_COMMAND_LINE_DESCRIPTION = "Workflow command line.";
+    public static final String WORKFLOW_SCRIPTS_DESCRIPTION = "List of scripts used by the Workflow.";
+    public static final String WORKFLOW_SOMATIC_DESCRIPTION = "Describes if the sample is somatic or not .";
+    public static final String WORKFLOW_INDIVIDUAL_ID_DESCRIPTION = "Individual id of the sample.";
+    public static final String WORKFLOW_FILE_IDS_DESCRIPTION = "File ids of the sample.";
+    public static final String WORKFLOW_COHORT_IDS_DESCRIPTION = "Cohort ids of the sample.";
+    public static final String WORKFLOW_INTERNAL_DESCRIPTION = "Sample internal information.";
+    public static final String WORKFLOW_EXTERNAL_SOURCE_DESCRIPTION = "The external source from where the example was imported.";
+
     //FileInternal
     public static final String FILE_INTERNAL_STATUS_DESCRIPTION = "File status can have the values READY, DELETED, "
             + "TRASHED, STAGE, MISSING, PENDING_DELETE, DELETING, REMOVED and MISSING_SAMPLES.";
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlowRunParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/NextFlowRunParams.java
similarity index 95%
rename from opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlowRunParams.java
rename to opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/NextFlowRunParams.java
index 062863b3916..8d99a80788c 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/NextFlowRunParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/NextFlowRunParams.java
@@ -1,4 +1,4 @@
-package org.opencb.opencga.core.models.nextflow;
+package org.opencb.opencga.core.models.workflow;
 
 import org.opencb.opencga.core.tools.ToolParams;
 
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
similarity index 62%
rename from opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/Workflow.java
rename to opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index 726cfeebe00..b9d37ac36c7 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/nextflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -1,21 +1,47 @@
-package org.opencb.opencga.core.models.nextflow;
+package org.opencb.opencga.core.models.workflow;
 
+import org.opencb.commons.annotations.DataField;
+import org.opencb.opencga.core.api.FieldConstants;
 import org.opencb.opencga.core.models.PrivateFields;
 
 import java.util.List;
+import java.util.Map;
 
 public class Workflow extends PrivateFields {
 
+    @DataField(id = "id", required = true, indexed = true, unique = true, immutable = true,
+            description = FieldConstants.WORKFLOW_ID_DESCRIPTION)
     private String id;
+
+    @DataField(id = "uuid", managed = true, indexed = true, unique = true, immutable = true,
+            description = FieldConstants.GENERIC_UUID_DESCRIPTION)
     private String uuid;
+
+    @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
+    private String description;
+
+    @DataField(id = "version", managed = true, indexed = true,
+            description = FieldConstants.GENERIC_VERSION_DESCRIPTION)
     private int version;
+
+    @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
     private Type type;
+
+    @DataField(id = "commandLine", description = FieldConstants.WORKFLOW_COMMAND_LINE_DESCRIPTION)
     private String commandLine;
+
+    @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
     private List<Script> scripts;
 
+    @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
+
+    @DataField(id = "modificationDate", indexed = true, description = FieldConstants.GENERIC_MODIFICATION_DATE_DESCRIPTION)
     private String modificationDate;
 
+    @DataField(id = "attributes", description = FieldConstants.GENERIC_ATTRIBUTES_DESCRIPTION)
+    private Map<String, Object> attributes;
+
     public enum Type {
         NEXTFLOW
     }
@@ -23,15 +49,17 @@ public enum Type {
     public Workflow() {
     }
 
-    public Workflow(String id, int version, Type type, String commandLine, List<Script> scripts, String creationDate,
-                    String modificationDate) {
+    public Workflow(String id, String description, int version, Type type, String commandLine, List<Script> scripts, String creationDate,
+                    String modificationDate, Map<String, Object> attributes) {
         this.id = id;
+        this.description = description;
         this.version = version;
         this.type = type;
         this.commandLine = commandLine;
         this.scripts = scripts;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
+        this.attributes = attributes;
     }
 
     @Override
@@ -39,12 +67,14 @@ public String toString() {
         final StringBuilder sb = new StringBuilder("Workflow{");
         sb.append("id='").append(id).append('\'');
         sb.append(", uuid='").append(uuid).append('\'');
+        sb.append(", description='").append(description).append('\'');
         sb.append(", version=").append(version);
         sb.append(", type=").append(type);
         sb.append(", commandLine='").append(commandLine).append('\'');
         sb.append(", scripts=").append(scripts);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
+        sb.append(", attributes=").append(attributes);
         sb.append('}');
         return sb.toString();
     }
@@ -67,6 +97,15 @@ public Workflow setUuid(String uuid) {
         return this;
     }
 
+    public String getDescription() {
+        return description;
+    }
+
+    public Workflow setDescription(String description) {
+        this.description = description;
+        return this;
+    }
+
     public int getVersion() {
         return version;
     }
@@ -121,6 +160,15 @@ public Workflow setModificationDate(String modificationDate) {
         return this;
     }
 
+    public Map<String, Object> getAttributes() {
+        return attributes;
+    }
+
+    public Workflow setAttributes(Map<String, Object> attributes) {
+        this.attributes = attributes;
+        return this;
+    }
+
     public static class Script {
 
         private String id;
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
new file mode 100644
index 00000000000..d5777615030
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -0,0 +1,130 @@
+package org.opencb.opencga.core.models.workflow;
+
+import org.opencb.commons.annotations.DataField;
+import org.opencb.opencga.core.api.FieldConstants;
+
+import java.util.List;
+import java.util.Map;
+
+public class WorkflowCreateParams {
+
+    @DataField(id = "id", required = true, indexed = true, unique = true, immutable = true,
+            description = FieldConstants.WORKFLOW_ID_DESCRIPTION)
+    private String id;
+
+    @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
+    private String description;
+
+//    @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
+//    private Workflow.Type type;
+
+    @DataField(id = "commandLine", description = FieldConstants.WORKFLOW_COMMAND_LINE_DESCRIPTION)
+    private String commandLine;
+
+    @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
+    private List<Workflow.Script> scripts;
+
+    @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
+    private String creationDate;
+
+    @DataField(id = "modificationDate", indexed = true, description = FieldConstants.GENERIC_MODIFICATION_DATE_DESCRIPTION)
+    private String modificationDate;
+
+    @DataField(id = "attributes", description = FieldConstants.GENERIC_ATTRIBUTES_DESCRIPTION)
+    private Map<String, Object> attributes;
+
+    public WorkflowCreateParams() {
+    }
+
+    public WorkflowCreateParams(String id, String description, String commandLine, List<Workflow.Script> scripts,
+                                String creationDate, String modificationDate, Map<String, Object> attributes) {
+        this.id = id;
+        this.description = description;
+        this.commandLine = commandLine;
+        this.scripts = scripts;
+        this.creationDate = creationDate;
+        this.modificationDate = modificationDate;
+        this.attributes = attributes;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowCreateParams{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", description='").append(description).append('\'');
+        sb.append(", commandLine='").append(commandLine).append('\'');
+        sb.append(", scripts=").append(scripts);
+        sb.append(", creationDate='").append(creationDate).append('\'');
+        sb.append(", modificationDate='").append(modificationDate).append('\'');
+        sb.append(", attributes=").append(attributes);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public Workflow toWorkflow() {
+        return new Workflow(id, description, 0, Workflow.Type.NEXTFLOW, commandLine, scripts, creationDate, modificationDate, attributes);
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public WorkflowCreateParams setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public WorkflowCreateParams setDescription(String description) {
+        this.description = description;
+        return this;
+    }
+
+    public String getCommandLine() {
+        return commandLine;
+    }
+
+    public WorkflowCreateParams setCommandLine(String commandLine) {
+        this.commandLine = commandLine;
+        return this;
+    }
+
+    public List<Workflow.Script> getScripts() {
+        return scripts;
+    }
+
+    public WorkflowCreateParams setScripts(List<Workflow.Script> scripts) {
+        this.scripts = scripts;
+        return this;
+    }
+
+    public String getCreationDate() {
+        return creationDate;
+    }
+
+    public WorkflowCreateParams setCreationDate(String creationDate) {
+        this.creationDate = creationDate;
+        return this;
+    }
+
+    public String getModificationDate() {
+        return modificationDate;
+    }
+
+    public WorkflowCreateParams setModificationDate(String modificationDate) {
+        this.modificationDate = modificationDate;
+        return this;
+    }
+
+    public Map<String, Object> getAttributes() {
+        return attributes;
+    }
+
+    public WorkflowCreateParams setAttributes(Map<String, Object> attributes) {
+        this.attributes = attributes;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
new file mode 100644
index 00000000000..5a37216dd7f
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
@@ -0,0 +1,108 @@
+package org.opencb.opencga.core.models.workflow;
+
+import org.opencb.commons.annotations.DataField;
+import org.opencb.opencga.core.api.FieldConstants;
+
+import java.util.List;
+import java.util.Map;
+
+public class WorkflowUpdateParams {
+
+    @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
+    private String description;
+
+    @DataField(id = "commandLine", description = FieldConstants.WORKFLOW_COMMAND_LINE_DESCRIPTION)
+    private String commandLine;
+
+    @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
+    private List<Workflow.Script> scripts;
+
+    @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
+    private String creationDate;
+
+    @DataField(id = "modificationDate", indexed = true, description = FieldConstants.GENERIC_MODIFICATION_DATE_DESCRIPTION)
+    private String modificationDate;
+
+    @DataField(id = "attributes", description = FieldConstants.GENERIC_ATTRIBUTES_DESCRIPTION)
+    private Map<String, Object> attributes;
+
+    public WorkflowUpdateParams() {
+    }
+
+    public WorkflowUpdateParams(String description, String commandLine, List<Workflow.Script> scripts,
+                                String creationDate, String modificationDate, Map<String, Object> attributes) {
+        this.description = description;
+        this.commandLine = commandLine;
+        this.scripts = scripts;
+        this.creationDate = creationDate;
+        this.modificationDate = modificationDate;
+        this.attributes = attributes;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowUpdateParams{");
+        sb.append("description='").append(description).append('\'');
+        sb.append(", commandLine='").append(commandLine).append('\'');
+        sb.append(", scripts=").append(scripts);
+        sb.append(", creationDate='").append(creationDate).append('\'');
+        sb.append(", modificationDate='").append(modificationDate).append('\'');
+        sb.append(", attributes=").append(attributes);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public WorkflowUpdateParams setDescription(String description) {
+        this.description = description;
+        return this;
+    }
+
+    public String getCommandLine() {
+        return commandLine;
+    }
+
+    public WorkflowUpdateParams setCommandLine(String commandLine) {
+        this.commandLine = commandLine;
+        return this;
+    }
+
+    public List<Workflow.Script> getScripts() {
+        return scripts;
+    }
+
+    public WorkflowUpdateParams setScripts(List<Workflow.Script> scripts) {
+        this.scripts = scripts;
+        return this;
+    }
+
+    public String getCreationDate() {
+        return creationDate;
+    }
+
+    public WorkflowUpdateParams setCreationDate(String creationDate) {
+        this.creationDate = creationDate;
+        return this;
+    }
+
+    public String getModificationDate() {
+        return modificationDate;
+    }
+
+    public WorkflowUpdateParams setModificationDate(String modificationDate) {
+        this.modificationDate = modificationDate;
+        return this;
+    }
+
+    public Map<String, Object> getAttributes() {
+        return attributes;
+    }
+
+    public WorkflowUpdateParams setAttributes(Map<String, Object> attributes) {
+        this.attributes = attributes;
+        return this;
+    }
+}

From 3031cc6fa96e4f9e543d5555026c4f46d47f90b9 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 8 Aug 2024 10:46:09 +0200
Subject: [PATCH 06/99] catalog: implement workflows under studies, #TASK-6445

---
 .../{tools => workflow}/NextFlowExecutor.java |  31 +-
 .../analysis/tools/WorkflowExecutorTest.java  |  64 ++---
 .../src/test/resources/nextflow/pipeline.nf   |  26 ++
 .../internal/InternalCliOptionsParser.java    |  11 +
 .../app/cli/internal/InternalMain.java        |   3 +
 .../executors/WorkflowCommandExecutor.java    |  54 ++++
 .../options/WorkflowCommandOptions.java       |  48 ++++
 .../authorization/AuthorizationManager.java   |   4 +
 .../CatalogAuthorizationManager.java          |  15 +
 .../catalog/db/api/WorkflowDBAdaptor.java     |   2 +-
 .../db/mongodb/WorkflowMongoDBAdaptor.java    |  25 +-
 .../opencga/catalog/managers/UserManager.java |   4 +
 .../catalog/managers/WorkflowManager.java     | 271 ++++++++++--------
 .../opencga/core/api/FieldConstants.java      |   4 +-
 .../core/models/study/StudyPermissions.java   |   9 +-
 .../core/models/workflow/Workflow.java        |  87 ++----
 .../models/workflow/WorkflowAclEntryList.java |   6 +
 .../models/workflow/WorkflowCreateParams.java |  40 ++-
 .../models/workflow/WorkflowPermissions.java  |  30 ++
 .../models/workflow/WorkflowRepository.java   |  30 ++
 .../core/models/workflow/WorkflowScript.java  |  61 ++++
 .../models/workflow/WorkflowUpdateParams.java |  42 ++-
 22 files changed, 601 insertions(+), 266 deletions(-)
 rename opencga-analysis/src/main/java/org/opencb/opencga/analysis/{tools => workflow}/NextFlowExecutor.java (89%)
 create mode 100644 opencga-analysis/src/test/resources/nextflow/pipeline.nf
 create mode 100644 opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/executors/WorkflowCommandExecutor.java
 create mode 100644 opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/options/WorkflowCommandOptions.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowAclEntryList.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowPermissions.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepository.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowScript.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
similarity index 89%
rename from opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
rename to opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index caf4b065117..1fcf6acdf0c 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -1,4 +1,4 @@
-package org.opencb.opencga.analysis.tools;
+package org.opencb.opencga.analysis.workflow;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -7,12 +7,14 @@
 import org.apache.commons.lang3.time.StopWatch;
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowScript;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
@@ -37,7 +39,7 @@
 import java.util.stream.Stream;
 
 @Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.WORKFLOW, description = NextFlowExecutor.DESCRIPTION)
-public class NextFlowExecutor extends OpenCgaTool {
+public class NextFlowExecutor extends OpenCgaToolScopeStudy {
 
     public final static String ID = "nextflow-run";
     public static final String DESCRIPTION = "Execute a Nextflow analysis.";
@@ -60,7 +62,7 @@ protected void check() throws Exception {
             throw new IllegalArgumentException("Missing Nextflow ID");
         }
 
-        OpenCGAResult<Workflow> result = catalogManager.getWorkflowManager().get(nextflowParams.getId(), QueryOptions.empty(), token);
+        OpenCGAResult<Workflow> result = catalogManager.getWorkflowManager().get(study, nextflowParams.getId(), QueryOptions.empty(), token);
         if (result.getNumResults() == 0) {
             throw new ToolException("Workflow '" + nextflowParams.getId() + "' not found");
         }
@@ -73,9 +75,9 @@ protected void check() throws Exception {
 
     @Override
     protected void run() throws Exception {
-        for (Workflow.Script script : workflow.getScripts()) {
+        for (WorkflowScript script : workflow.getScripts()) {
             // Write script files
-            Files.write(getOutDir().resolve(script.getId()), script.getContent().getBytes());
+            Files.write(getOutDir().resolve(script.getFilename()), script.getContent().getBytes());
         }
 
         // Write nextflow.config file
@@ -91,8 +93,19 @@ protected void run() throws Exception {
 
         StringBuilder stringBuilder = new StringBuilder()
                 .append("nextflow -c ").append(workingDirectory).append("/nextflow.config")
-                .append(" ").append(workflow.getCommandLine())
-                .append(" -with-report ").append(workingDirectory).append("/report.html");
+                .append(" run ");
+        if (workflow.getDocker() != null && StringUtils.isNotEmpty(workflow.getDocker().getImage())) {
+            stringBuilder.append(workflow.getDocker().getImage()).append(" -with-docker");
+        } else {
+            for (WorkflowScript script : workflow.getScripts()) {
+                if (script.isMain()) {
+                    stringBuilder.append(workingDirectory).append("/").append(script.getFilename());
+                    break;
+                }
+            }
+        }
+
+        stringBuilder.append(" -with-report ").append(workingDirectory).append("/report.html");
         List<String> cliArgs = Arrays.asList(StringUtils.split(stringBuilder.toString(), " "));
 
         startTraceFileMonitor();
@@ -125,8 +138,8 @@ protected void run() throws Exception {
         logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
 
         // Delete input files
-        for (Workflow.Script script : workflow.getScripts()) {
-            Files.delete(getOutDir().resolve(script.getId()));
+        for (WorkflowScript script : workflow.getScripts()) {
+            Files.delete(getOutDir().resolve(script.getFilename()));
         }
         Files.delete(getOutDir().resolve("nextflow.config"));
 
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index c80d59681fe..768ce6e4981 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -1,16 +1,21 @@
 package org.opencb.opencga.analysis.tools;
 
+import org.apache.commons.io.IOUtils;
 import org.apache.commons.lang3.time.StopWatch;
 import org.junit.Test;
+import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.opencga.analysis.StorageManager;
+import org.opencb.opencga.analysis.workflow.NextFlowExecutor;
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.managers.AbstractManagerTest;
+import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.config.storage.StorageConfiguration;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
-import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
+import org.opencb.opencga.core.models.workflow.WorkflowRepository;
+import org.opencb.opencga.core.models.workflow.WorkflowScript;
 import org.opencb.opencga.storage.core.StorageEngineFactory;
 
 import java.io.IOException;
@@ -28,15 +33,17 @@ public void nextflowScriptTest() throws ToolException, CatalogException, IOExcep
         StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
 
         WorkflowCreateParams workflow = createDummyWorkflow();
-        catalogManager.getWorkflowManager().create(workflow, QueryOptions.empty(), ownerToken);
+        catalogManager.getWorkflowManager().create(studyFqn, workflow.toWorkflow(), QueryOptions.empty(), ownerToken);
 
         Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
 
         StopWatch stopWatch = StopWatch.createStarted();
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
         NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1);
+        ObjectMap params = runParams.toObjectMap();
+        params.put(ParamConstants.STUDY_PARAM, studyFqn);
         nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), catalogManager,
-                StorageEngineFactory.get(storageConfiguration), runParams.toObjectMap(), outDir, "", false, ownerToken);
+                StorageEngineFactory.get(storageConfiguration), params, outDir, "", false, ownerToken);
 //        nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), runParams.toObjectMap(), outDir, ownerToken);
         nextFlowExecutorTest.start();
         System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
@@ -48,59 +55,28 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
         WorkflowCreateParams workflow = new WorkflowCreateParams()
                 .setId("workflow")
-                .setCommandLine("run nextflow-io/rnaseq-nf -with-docker");
-        catalogManager.getWorkflowManager().create(workflow, QueryOptions.empty(), ownerToken);
+//                .setCommandLine("run nextflow-io/rnaseq-nf -with-docker");
+                .setDocker(new WorkflowRepository("nextflow-io/rnaseq-nf"));
+        catalogManager.getWorkflowManager().create(studyFqn, workflow.toWorkflow(), QueryOptions.empty(), ownerToken);
 
         Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
 
         StopWatch stopWatch = StopWatch.createStarted();
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
         NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1);
+        ObjectMap params = runParams.toObjectMap();
+        params.put(ParamConstants.STUDY_PARAM, studyFqn);
         nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), catalogManager,
-                StorageEngineFactory.get(storageConfiguration), runParams.toObjectMap(), outDir, "", false, ownerToken);
+                StorageEngineFactory.get(storageConfiguration), params, outDir, "", false, ownerToken);
         nextFlowExecutorTest.start();
         System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
     }
 
-    private WorkflowCreateParams createDummyWorkflow() {
-        String scriptContent = "params.str = 'Hello world!'\n" +
-                "\n" +
-                "process splitLetters {\n" +
-                "    output:\n" +
-                "    path 'chunk_*'\n" +
-                "\n" +
-                "    \"\"\"\n" +
-                "    printf '${params.str}' | split -b 6 - chunk_\n" +
-                "    \"\"\"\n" +
-                "}\n" +
-                "\n" +
-                "process convertToUpper {\n" +
-                "    input:\n" +
-                "    path x\n" +
-                "\n" +
-                "    output:\n" +
-                "    stdout\n" +
-                "\n" +
-                "    \"\"\"\n" +
-                "    cat $x | tr '[a-z]' '[A-Z]'\n" +
-                "    \"\"\"\n" +
-                "}\n" +
-                "\n" +
-                "process sleep {\n" +
-                "    input:\n" +
-                "    val x\n" +
-                "\n" +
-                "    \"\"\"\n" +
-                "    sleep 6\n" +
-                "    \"\"\"\n" +
-                "}\n" +
-                "\n" +
-                "workflow {\n" +
-                "    splitLetters | flatten | convertToUpper | view { it.trim() } | sleep\n" +
-                "}";
+    private WorkflowCreateParams createDummyWorkflow() throws IOException {
+        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("nextflow/pipeline.nf");
+        String content = IOUtils.toString(inputStream, "UTF-8");
         return new WorkflowCreateParams()
                 .setId("workflow")
-                .setCommandLine("run pipeline.nf")
-                .setScripts(Collections.singletonList(new Workflow.Script("pipeline.nf", scriptContent)));
+                .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", content, true)));
     }
 }
diff --git a/opencga-analysis/src/test/resources/nextflow/pipeline.nf b/opencga-analysis/src/test/resources/nextflow/pipeline.nf
new file mode 100644
index 00000000000..f457ff3deb3
--- /dev/null
+++ b/opencga-analysis/src/test/resources/nextflow/pipeline.nf
@@ -0,0 +1,26 @@
+params.str = 'Hello world!'
+
+process splitLetters {
+    output:
+    path 'chunk_*'
+
+    """
+    printf '${params.str}' | split -b 6 - chunk_
+    """
+}
+
+process convertToUpper {
+    input:
+    path x
+
+    output:
+    stdout
+
+    """
+    cat $x | tr '[a-z]' '[A-Z]'
+    """
+}
+
+workflow {
+    splitLetters | flatten | convertToUpper | view { it.trim() }
+}
\ No newline at end of file
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/InternalCliOptionsParser.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/InternalCliOptionsParser.java
index 96522720e12..306d3563a58 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/InternalCliOptionsParser.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/InternalCliOptionsParser.java
@@ -21,6 +21,7 @@
 import com.beust.jcommander.Parameters;
 import com.beust.jcommander.ParametersDelegate;
 import org.opencb.commons.utils.CommandLineUtils;
+import org.opencb.opencga.analysis.workflow.NextFlowExecutor;
 import org.opencb.opencga.app.cli.CliOptionsParser;
 import org.opencb.opencga.app.cli.GeneralCliOptions;
 import org.opencb.opencga.app.cli.internal.options.*;
@@ -111,6 +112,7 @@ public class InternalCliOptionsParser extends CliOptionsParser {
     private JobCommandOptions jobCommandOptions;
     private DiseasePanelInternalCommandOptions panelInternalCommandOptions;
     private StudyCommandOptions studyCommandOptions;
+    private WorkflowCommandOptions workflowCommandOptions;
 
     public InternalCliOptionsParser() {
         jCommander.setProgramName("opencga-internal.sh");
@@ -278,6 +280,11 @@ public InternalCliOptionsParser() {
         jCommander.addCommand("studies", studyCommandOptions);
         JCommander studySubcommands = jCommander.getCommands().get("studies");
         studySubcommands.addCommand(TEMPLATE_RUN_COMMAND, studyCommandOptions.templateLoader);
+
+        workflowCommandOptions = new WorkflowCommandOptions(commonCommandOptions, jCommander);
+        jCommander.addCommand("workflows", workflowCommandOptions);
+        JCommander workflowSubcommands = jCommander.getCommands().get("workflows");
+        workflowSubcommands.addCommand(NextFlowExecutor.ID, workflowCommandOptions.nextflowCommandOptions);
     }
 
     @Override
@@ -562,4 +569,8 @@ public DiseasePanelInternalCommandOptions getPanelInternalCommandOptions() {
     public StudyCommandOptions getStudyCommandOptions() {
         return studyCommandOptions;
     }
+
+    public WorkflowCommandOptions getWorkflowCommandOptions() {
+        return workflowCommandOptions;
+    }
 }
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/InternalMain.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/InternalMain.java
index 98d8b965357..f6da922de00 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/InternalMain.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/InternalMain.java
@@ -112,6 +112,9 @@ public static int privateMain(String[] args) {
                         case "studies":
                             commandExecutor = new StudyCommandExecutor(cliOptionsParser.getStudyCommandOptions());
                             break;
+                        case "workflows":
+                            commandExecutor = new WorkflowCommandExecutor(cliOptionsParser.getWorkflowCommandOptions());
+                            break;
                         default:
                             System.err.printf("ERROR: not valid command passed: '" + parsedCommand + "'");
                             break;
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/executors/WorkflowCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/executors/WorkflowCommandExecutor.java
new file mode 100644
index 00000000000..df9905efe11
--- /dev/null
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/executors/WorkflowCommandExecutor.java
@@ -0,0 +1,54 @@
+package org.opencb.opencga.app.cli.internal.executors;
+
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.opencga.analysis.workflow.NextFlowExecutor;
+import org.opencb.opencga.app.cli.internal.options.WorkflowCommandOptions;
+import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class WorkflowCommandExecutor extends InternalCommandExecutor {
+
+    private final WorkflowCommandOptions workflowCommandOptions;
+
+    private String jobId;
+    private boolean dryRun;
+
+    public WorkflowCommandExecutor(WorkflowCommandOptions options) {
+        super(options.workflowCommonOptions);
+        workflowCommandOptions = options;
+    }
+
+    @Override
+    public void execute() throws Exception {
+        logger.debug("Executing workflow command line");
+
+        jobId = workflowCommandOptions.internalJobOptions.jobId;
+        dryRun = workflowCommandOptions.internalJobOptions.dryRun;
+
+        String subCommandString = getParsedSubCommand(workflowCommandOptions.jCommander);
+        configure();
+        switch (subCommandString) {
+            case "nextflow-run":
+                nextflowRun();
+                break;
+            default:
+                logger.error("Subcommand not valid");
+                break;
+
+        }
+    }
+
+    private void nextflowRun() throws ToolException {
+        WorkflowCommandOptions.NextflowCommandOptions options = workflowCommandOptions.nextflowCommandOptions;
+
+        Path outDir = Paths.get(options.outDir);
+
+        NextFlowRunParams nextFlowRunParams = new NextFlowRunParams();
+        nextFlowRunParams.setId(options.workflowId);
+
+        toolRunner.execute(NextFlowExecutor.class, nextFlowRunParams, QueryOptions.empty(), outDir, jobId, dryRun, token);
+    }
+}
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/options/WorkflowCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/options/WorkflowCommandOptions.java
new file mode 100644
index 00000000000..ca6d4c8e816
--- /dev/null
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/options/WorkflowCommandOptions.java
@@ -0,0 +1,48 @@
+package org.opencb.opencga.app.cli.internal.options;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.Parameters;
+import com.beust.jcommander.ParametersDelegate;
+import org.opencb.opencga.analysis.workflow.NextFlowExecutor;
+import org.opencb.opencga.app.cli.GeneralCliOptions;
+import org.opencb.opencga.app.cli.internal.InternalCliOptionsParser;
+
+@Parameters(commandNames = {"workflows"}, commandDescription = "Execute workflows")
+public class WorkflowCommandOptions {
+
+    public final static String OUTDIR_PARAM_NAME = "outdir";
+    public final GeneralCliOptions.CommonCommandOptions workflowCommonOptions;
+    public final InternalCliOptionsParser.JobOptions internalJobOptions;
+    public JCommander jCommander;
+
+    public final NextflowCommandOptions nextflowCommandOptions;
+
+    public WorkflowCommandOptions(GeneralCliOptions.CommonCommandOptions workflowCommonOptions, JCommander jCommander) {
+        this.workflowCommonOptions = workflowCommonOptions;
+        this.internalJobOptions = new InternalCliOptionsParser.JobOptions();
+        this.jCommander = jCommander;
+
+        this.nextflowCommandOptions = new NextflowCommandOptions();
+    }
+
+    @Parameters(commandNames = {NextFlowExecutor.ID}, commandDescription = NextFlowExecutor.DESCRIPTION)
+    public class NextflowCommandOptions {
+        @ParametersDelegate
+        public GeneralCliOptions.CommonCommandOptions commonOptions = workflowCommonOptions;
+
+        @ParametersDelegate
+        public InternalCliOptionsParser.JobOptions jobOptions = internalJobOptions;
+
+//        @Parameter(names = {"-s", "--" + ParamConstants.STUDY_PARAM}, description = "Study [[organization@]project:]study.",
+//        required = true, arity = 1)
+//        public String studyId;
+
+        @Parameter(names = {"--workflow-id"}, description = "Workflow id", required = true, arity = 1)
+        public String workflowId;
+
+        @Parameter(names = {"-o", "--" + OUTDIR_PARAM_NAME}, description = "Directory where output files will be saved", required = true,
+                arity = 1)
+        public String outDir;
+    }
+}
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/AuthorizationManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/AuthorizationManager.java
index 0b2661baa46..722207acce5 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/AuthorizationManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/AuthorizationManager.java
@@ -35,6 +35,7 @@
 import org.opencb.opencga.core.models.study.PermissionRule;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.models.study.StudyPermissions;
+import org.opencb.opencga.core.models.workflow.WorkflowPermissions;
 import org.opencb.opencga.core.response.OpenCGAResult;
 
 import javax.annotation.Nullable;
@@ -225,6 +226,9 @@ void checkFamilyPermission(String organizationId, long studyId, long familyId, S
     void checkClinicalAnalysisPermission(String organizationId, long studyId, long analysisId, String userId,
                                          ClinicalAnalysisPermissions permission) throws CatalogException;
 
+    void checkWorkflowPermission(String organizationId, long studyUid, long workflowUid, String userId, WorkflowPermissions permission)
+            throws CatalogException;
+
     default List<Acl> getEffectivePermissions(String organizationId, long studyUid, String resourceId, Enums.Resource resource)
             throws CatalogException {
         return getEffectivePermissions(organizationId, studyUid, Collections.singletonList(resourceId), Collections.emptyList(), resource);
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/CatalogAuthorizationManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/CatalogAuthorizationManager.java
index 7022be4a0e7..b3374341da9 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/CatalogAuthorizationManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/CatalogAuthorizationManager.java
@@ -46,6 +46,7 @@
 import org.opencb.opencga.core.models.study.PermissionRule;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.models.study.StudyPermissions;
+import org.opencb.opencga.core.models.workflow.WorkflowPermissions;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -443,6 +444,20 @@ public void checkClinicalAnalysisPermission(String organizationId, long studyId,
         throw CatalogAuthorizationException.deny(userId, permission.toString(), "ClinicalAnalysis", analysisId, null);
     }
 
+    @Override
+    public void checkWorkflowPermission(String organizationId, long studyUid, long workflowUid, String userId,
+                                        WorkflowPermissions permission) throws CatalogException {
+        Query query = new Query()
+                .append(WorkflowDBAdaptor.QueryParams.UID.key(), workflowUid)
+                .append(WorkflowDBAdaptor.QueryParams.STUDY_UID.key(), studyUid)
+                .append(ParamConstants.ACL_PARAM, userId + ":" + permission.name());
+
+        if (checkUserPermission(organizationId, userId, query, dbAdaptorFactory.getWorkflowDBAdaptor(organizationId))) {
+            return;
+        }
+        throw CatalogAuthorizationException.deny(userId, permission.toString(), "Workflow", workflowUid, null);
+    }
+
     @Override
     public List<Acl> getEffectivePermissions(String organizationId, long studyUid, List<String> resourceIdList, List<String> permissions,
                                              Enums.Resource resource) throws CatalogException {
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
index fddf1dd5898..d9761163f77 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
@@ -15,7 +15,7 @@
 
 public interface WorkflowDBAdaptor extends CoreDBAdaptor<Workflow> {
 
-    OpenCGAResult<Workflow> insert(Workflow workflow, QueryOptions options)
+    OpenCGAResult<Workflow> insert(long studyUid, Workflow workflow, QueryOptions options)
             throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException;
 
     enum QueryParams implements QueryParam {
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index 0b62903cf8f..522011fa07c 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -21,6 +21,7 @@
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Configuration;
 import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowScript;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.slf4j.LoggerFactory;
 
@@ -53,13 +54,17 @@ public WorkflowMongoDBAdaptor(MongoDBCollection workflowCollection, MongoDBColle
         this.workflowConverter = new WorkflowConverter();
     }
 
-    Workflow insert(ClientSession clientSession, Workflow workflow) throws CatalogDBException {
+    Workflow insert(ClientSession clientSession, long studyUid, Workflow workflow) throws CatalogDBException {
+        dbAdaptorFactory.getCatalogStudyDBAdaptor().checkId(studyUid);
         if (StringUtils.isEmpty(workflow.getId())) {
             throw new CatalogDBException("Missing workflow id");
         }
 
         // Check the workflow does not exist
-        Bson bson = Filters.eq(QueryParams.ID.key(), workflow.getId());
+        Bson bson = Filters.and(
+                Filters.eq(QueryParams.ID.key(), workflow.getId()),
+                Filters.eq(QueryParams.STUDY_UID.key(), studyUid)
+        );
         DataResult<Long> count = workflowCollection.count(clientSession, bson);
         if (count.getNumMatches() > 0) {
             throw new CatalogDBException("Workflow { id: '" + workflow.getId() + "'} already exists.");
@@ -67,6 +72,7 @@ Workflow insert(ClientSession clientSession, Workflow workflow) throws CatalogDB
 
         long uid = getNewUid(clientSession);
         workflow.setUid(uid);
+        workflow.setStudyUid(studyUid);
 
         Document workflowObject = workflowConverter.convertToStorageType(workflow);
 
@@ -83,13 +89,13 @@ Workflow insert(ClientSession clientSession, Workflow workflow) throws CatalogDB
     }
 
     @Override
-    public OpenCGAResult<Workflow> insert(Workflow workflow, QueryOptions options)
+    public OpenCGAResult<Workflow> insert(long studyUid, Workflow workflow, QueryOptions options)
             throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
         return runTransaction(clientSession -> {
             long tmpStartTime = startQuery();
             logger.debug("Starting workflow insert transaction for workflow id '{}'", workflow.getId());
 
-            insert(clientSession, workflow);
+            insert(clientSession, studyUid, workflow);
             return endWrite(tmpStartTime, 1, 1, 0, 0, null);
         }, e -> logger.error("Could not create workflow {}: {}", workflow.getId(), e.getMessage()));
     }
@@ -312,7 +318,7 @@ private UpdateDocument parseAndValidateUpdateParams(ObjectMap parameters, QueryO
 
         // Check if the tags exist.
         if (parameters.containsKey(QueryParams.SCRIPTS.key())) {
-            List<Workflow.Script> scriptList = parameters.getAsList(QueryParams.SCRIPTS.key(), Workflow.Script.class);
+            List<WorkflowScript> scriptList = parameters.getAsList(QueryParams.SCRIPTS.key(), WorkflowScript.class);
 
             if (!scriptList.isEmpty()) {
                 Map<String, Object> actionMap = queryOptions.getMap(Constants.ACTIONS, new HashMap<>());
@@ -435,15 +441,18 @@ private Bson parseQuery(Query query, String user) throws CatalogDBException, Cat
                     case UID:
                         addAutoOrQuery(PRIVATE_UID, queryParam.key(), queryCopy, queryParam.type(), andBsonList);
                         break;
-//                    case SNAPSHOT:
-//                        addAutoOrQuery(RELEASE_FROM_VERSION, queryParam.key(), queryCopy, queryParam.type(), andBsonList);
-//                        break;
+                    case SNAPSHOT:
+                        addAutoOrQuery(RELEASE_FROM_VERSION, queryParam.key(), queryCopy, queryParam.type(), andBsonList);
+                        break;
                     case CREATION_DATE:
                         addAutoOrQuery(PRIVATE_CREATION_DATE, queryParam.key(), queryCopy, queryParam.type(), andBsonList);
                         break;
                     case MODIFICATION_DATE:
                         addAutoOrQuery(PRIVATE_MODIFICATION_DATE, queryParam.key(), query, queryParam.type(), andBsonList);
                         break;
+                    case STUDY_UID:
+                        addAutoOrQuery(PRIVATE_STUDY_UID, queryParam.key(), queryCopy, queryParam.type(), andBsonList);
+                        break;
 //                    case STATUS:
 //                    case STATUS_ID:
 //                        addAutoOrQuery(WorkflowDBAdaptor.QueryParams.STATUS_ID.key(), queryParam.key(), query,
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/UserManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/UserManager.java
index 4c9f03d12e1..1491c1a2642 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/UserManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/UserManager.java
@@ -257,6 +257,10 @@ public OpenCGAResult<User> search(@Nullable String organizationId, Query query,
     }
 
     public JwtPayload validateToken(String token) throws CatalogException {
+        if (StringUtils.isEmpty(token)) {
+            throw new CatalogException("Missing token parameter");
+        }
+
         JwtPayload jwtPayload = new JwtPayload(token);
         ParamUtils.checkParameter(jwtPayload.getUserId(), "jwt user");
         ParamUtils.checkParameter(jwtPayload.getOrganization(), "jwt organization");
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 2c0886fa80b..b50dd4b96c4 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -1,19 +1,23 @@
 package org.opencb.opencga.catalog.managers;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
-import org.opencb.commons.datastore.core.Event;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.Query;
 import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.commons.utils.ListUtils;
 import org.opencb.opencga.catalog.auth.authorization.AuthorizationManager;
 import org.opencb.opencga.catalog.db.DBAdaptorFactory;
+import org.opencb.opencga.catalog.db.api.DBIterator;
 import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
+import org.opencb.opencga.catalog.exceptions.CatalogAuthorizationException;
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
 import org.opencb.opencga.catalog.io.CatalogIOManager;
 import org.opencb.opencga.catalog.io.IOManagerFactory;
 import org.opencb.opencga.catalog.models.InternalGetDataResult;
+import org.opencb.opencga.catalog.utils.CatalogFqn;
 import org.opencb.opencga.catalog.utils.Constants;
 import org.opencb.opencga.catalog.utils.ParamUtils;
 import org.opencb.opencga.catalog.utils.UuidUtils;
@@ -22,24 +26,29 @@
 import org.opencb.opencga.core.models.JwtPayload;
 import org.opencb.opencga.core.models.audit.AuditRecord;
 import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.study.Study;
+import org.opencb.opencga.core.models.study.StudyPermissions;
 import org.opencb.opencga.core.models.workflow.Workflow;
-import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
+import org.opencb.opencga.core.models.workflow.WorkflowRepository;
+import org.opencb.opencga.core.models.workflow.WorkflowScript;
 import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.*;
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 
+import static org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor.QueryParams.*;
 import static org.opencb.opencga.core.common.JacksonUtils.getUpdateObjectMapper;
 
-public class WorkflowManager extends AbstractManager {
+public class WorkflowManager extends ResourceManager<Workflow> {
 
-    public static final QueryOptions INCLUDE_WORKFLOW_IDS = new QueryOptions(QueryOptions.INCLUDE, Arrays.asList(
-            WorkflowDBAdaptor.QueryParams.ID.key(), WorkflowDBAdaptor.QueryParams.UID.key(), WorkflowDBAdaptor.QueryParams.UUID.key(),
-            WorkflowDBAdaptor.QueryParams.VERSION.key()));
+    public static final QueryOptions INCLUDE_WORKFLOW_IDS = new QueryOptions(QueryOptions.INCLUDE, Arrays.asList(ID.key(), UID.key(),
+            UUID.key(), VERSION.key()));
 
     private final CatalogIOManager catalogIOManager;
     private final IOManagerFactory ioManagerFactory;
@@ -57,18 +66,26 @@ public class WorkflowManager extends AbstractManager {
     }
 
 
-    private InternalGetDataResult<Workflow> internalGet(String organizationId, List<String> workflowList, Query query, QueryOptions options,
-                                                        String userId, boolean ignoreException) throws CatalogException {
-        if (ListUtils.isEmpty(workflowList)) {
+    @Override
+    Enums.Resource getEntity() {
+        return Enums.Resource.WORKFLOW;
+    }
+
+    @Override
+    InternalGetDataResult<Workflow> internalGet(String organizationId, long studyUid, List<String> workflowIdList, @Nullable Query query,
+                                                QueryOptions options, String user, boolean ignoreException) throws CatalogException {
+        if (ListUtils.isEmpty(workflowIdList)) {
             throw new CatalogException("Missing workflow entries.");
         }
-        List<String> uniqueList = ListUtils.unique(workflowList);
+        List<String> uniqueList = ListUtils.unique(workflowIdList);
 
         QueryOptions queryOptions = new QueryOptions(ParamUtils.defaultObject(options, QueryOptions::new));
+
         Query queryCopy = query == null ? new Query() : new Query(query);
+        queryCopy.put(STUDY_UID.key(), studyUid);
 
         boolean versioned = queryCopy.getBoolean(Constants.ALL_VERSIONS)
-                || queryCopy.containsKey(WorkflowDBAdaptor.QueryParams.VERSION.key());
+                || queryCopy.containsKey(VERSION.key());
         if (versioned && uniqueList.size() > 1) {
             throw new CatalogException("Only one workflow allowed when requesting multiple versions");
         }
@@ -79,99 +96,81 @@ private InternalGetDataResult<Workflow> internalGet(String organizationId, List<
         // Ensure the field by which we are querying for will be kept in the results
         queryOptions = keepFieldInQueryOptions(queryOptions, idQueryParam.key());
 
-        OpenCGAResult<Workflow> workflowResult = getWorkflowDBAdaptor(organizationId).get(queryCopy, queryOptions);
+        OpenCGAResult<Workflow> workflowResult = getWorkflowDBAdaptor(organizationId).get(studyUid, queryCopy, queryOptions, user);
 
         Function<Workflow, String> workflowStringFunction = Workflow::getId;
-        if (idQueryParam.equals(WorkflowDBAdaptor.QueryParams.UUID)) {
+        if (idQueryParam.equals(UUID)) {
             workflowStringFunction = Workflow::getUuid;
         }
 
         if (ignoreException || workflowResult.getNumResults() >= uniqueList.size()) {
             return keepOriginalOrder(uniqueList, workflowStringFunction, workflowResult, ignoreException, versioned);
-        } else {
-            throw CatalogException.notFound("workflows", getMissingFields(uniqueList, workflowResult.getResults(), workflowStringFunction));
         }
-    }
+        // Query without adding the user check
+        OpenCGAResult<Workflow> resultsNoCheck = getWorkflowDBAdaptor(organizationId).get(queryCopy, queryOptions);
 
-    private WorkflowDBAdaptor.QueryParams getFieldFilter(List<String> idList) throws CatalogException {
-        WorkflowDBAdaptor.QueryParams idQueryParam = null;
-        for (String entry : idList) {
-            WorkflowDBAdaptor.QueryParams param = WorkflowDBAdaptor.QueryParams.ID;
-            if (UuidUtils.isOpenCgaUuid(entry)) {
-                param = WorkflowDBAdaptor.QueryParams.UUID;
-            }
-            if (idQueryParam == null) {
-                idQueryParam = param;
-            }
-            if (idQueryParam != param) {
-                throw new CatalogException("Found uuids and ids in the same query. Please, choose one or do two different queries.");
-            }
+        if (resultsNoCheck.getNumResults() == workflowResult.getNumResults()) {
+            throw CatalogException.notFound("workflows", getMissingFields(uniqueList, workflowResult.getResults(), workflowStringFunction));
+        } else {
+            throw new CatalogAuthorizationException("Permission denied. " + user + " is not allowed to see some or none of the workflows.");
         }
-        return idQueryParam;
     }
 
-    public OpenCGAResult<Workflow> create(WorkflowCreateParams createParams, QueryOptions options, String token) throws CatalogException {
+    @Override
+    public OpenCGAResult<Workflow> create(String studyStr, Workflow workflow, QueryOptions options, String token) throws CatalogException {
         options = ParamUtils.defaultObject(options, QueryOptions::new);
 
         JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+
         ObjectMap auditParams = new ObjectMap()
-                .append("workflow", createParams)
+                .append("study", studyStr)
+                .append("workflow", workflow)
                 .append("options", options)
                 .append("token", token);
 
-        String organizationId = tokenPayload.getOrganization();
+        String organizationId = studyFqn.getOrganizationId();
         String userId = tokenPayload.getUserId(organizationId);
-
-        // 0. Create the workflow object
-        Workflow workflow = createParams.toWorkflow();
+        String studyId = studyFqn.getStudyId();
+        String studyUuid = studyFqn.getStudyUuid();
         try {
+            Study study = catalogManager.getStudyManager().resolveId(studyFqn, StudyManager.INCLUDE_VARIABLE_SET, tokenPayload);
+            studyId = study.getId();
+            studyUuid = study.getUuid();
+
             // 1. Check permissions
-            authorizationManager.checkIsAtLeastOrganizationOwnerOrAdmin(organizationId, userId);
+            authorizationManager.checkStudyPermission(organizationId, study.getUid(), tokenPayload,
+                    StudyPermissions.Permissions.WRITE_WORKFLOWS);
 
             // 2. Validate the workflow parameters
             validateNewWorkflow(workflow);
 
             // 3. We insert the workflow
-            OpenCGAResult<Workflow> insert = getWorkflowDBAdaptor(organizationId).insert(workflow, options);
+            OpenCGAResult<Workflow> insert = getWorkflowDBAdaptor(organizationId).insert(study.getUid(), workflow, options);
             if (options.getBoolean(ParamConstants.INCLUDE_RESULT_PARAM)) {
                 // Fetch created workflow
                 Query query = new Query()
-                        .append(WorkflowDBAdaptor.QueryParams.UID.key(), workflow.getUid());
+                        .append(STUDY_UID.key(), study.getUid())
+                        .append(UID.key(), workflow.getUid());
                 OpenCGAResult<Workflow> result = getWorkflowDBAdaptor(organizationId).get(query, options);
                 insert.setResults(result.getResults());
             }
-            auditManager.auditCreate(organizationId, userId, Enums.Resource.WORKFLOW, workflow.getId(), workflow.getUuid(), "", "",
-                    auditParams, new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+            auditManager.auditCreate(organizationId, userId, Enums.Resource.WORKFLOW, workflow.getId(), workflow.getUuid(), studyId,
+                    studyUuid, auditParams, new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
             return insert;
         } catch (CatalogException e) {
-            auditManager.auditCreate(organizationId, userId, Enums.Resource.WORKFLOW, workflow.getId(), "", "", "", auditParams,
+            auditManager.auditCreate(organizationId, userId, Enums.Resource.WORKFLOW, workflow.getId(), "", studyId, studyUuid, auditParams,
                     new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
             throw e;
         }
     }
 
-    private void validateNewWorkflow(Workflow workflow) throws CatalogParameterException {
-        ParamUtils.checkIdentifier(workflow.getId(), WorkflowDBAdaptor.QueryParams.ID.key());
-        ParamUtils.checkObj(workflow.getType(), WorkflowDBAdaptor.QueryParams.TYPE.key());
-        ParamUtils.checkParameter(workflow.getCommandLine(), WorkflowDBAdaptor.QueryParams.COMMAND_LINE.key());
-        workflow.setScripts(workflow.getScripts() != null ? workflow.getScripts() : Collections.emptyList());
-        for (Workflow.Script script : workflow.getScripts()) {
-            ParamUtils.checkIdentifier(script.getId(), WorkflowDBAdaptor.QueryParams.SCRIPTS.key() + ".id");
-            ParamUtils.checkParameter(script.getContent(), WorkflowDBAdaptor.QueryParams.SCRIPTS.key() + ".content");
-        }
-        workflow.setUuid(UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.WORKFLOW));
-        workflow.setVersion(1);
-        workflow.setCreationDate(ParamUtils.checkDateOrGetCurrentDate(workflow.getCreationDate(),
-                WorkflowDBAdaptor.QueryParams.CREATION_DATE.key()));
-        workflow.setModificationDate(ParamUtils.checkDateOrGetCurrentDate(workflow.getModificationDate(),
-                WorkflowDBAdaptor.QueryParams.MODIFICATION_DATE.key()));
-    }
-
-    public OpenCGAResult<Workflow> update(String workflowId, WorkflowUpdateParams updateParams, QueryOptions options, String token)
-            throws CatalogException {
+    public OpenCGAResult<Workflow> update(String studyStr, String workflowId, WorkflowUpdateParams updateParams, QueryOptions options,
+                                          String token) throws CatalogException {
         options = ParamUtils.defaultObject(options, QueryOptions::new);
 
         JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
         ObjectMap updateMap = null;
         try {
             if (updateParams != null) {
@@ -187,17 +186,23 @@ public OpenCGAResult<Workflow> update(String workflowId, WorkflowUpdateParams up
                 .append("options", options)
                 .append("token", token);
 
-        String organizationId = tokenPayload.getOrganization();
+        String organizationId = studyFqn.getOrganizationId();
         String userId = tokenPayload.getUserId(organizationId);
+        String studyId = studyFqn.getStudyId();
+        String studyUuid = studyFqn.getStudyUuid();
 
         String id = UuidUtils.isOpenCgaUuid(workflowId) ? "" : workflowId;
         String uuid = UuidUtils.isOpenCgaUuid(workflowId) ? workflowId : "";
         try {
+            Study study = catalogManager.getStudyManager().resolveId(studyFqn, StudyManager.INCLUDE_VARIABLE_SET, tokenPayload);
+            studyId = study.getId();
+            studyUuid = study.getUuid();
+
             // 1. Check permissions
             authorizationManager.checkIsAtLeastOrganizationOwnerOrAdmin(organizationId, userId);
 
-            Workflow workflow = internalGet(organizationId, Collections.singletonList(workflowId), null, INCLUDE_WORKFLOW_IDS, userId,
-                    false).first();
+            Workflow workflow = internalGet(organizationId, study.getUid(), Collections.singletonList(workflowId), null,
+                    INCLUDE_WORKFLOW_IDS, userId, false).first();
             id = workflow.getId();
             uuid = workflow.getUuid();
 
@@ -206,77 +211,109 @@ public OpenCGAResult<Workflow> update(String workflowId, WorkflowUpdateParams up
             if (options.getBoolean(ParamConstants.INCLUDE_RESULT_PARAM)) {
                 // Fetch updated workflow
                 Query query = new Query()
-                        .append(WorkflowDBAdaptor.QueryParams.UID.key(), workflow.getUid());
+                        .append(UID.key(), workflow.getUid());
                 OpenCGAResult<Workflow> result = getWorkflowDBAdaptor(organizationId).get(query, options);
                 insert.setResults(result.getResults());
             }
-            auditManager.auditUpdate(organizationId, userId, Enums.Resource.WORKFLOW, id, uuid, "", "", auditParams,
+            auditManager.auditUpdate(organizationId, userId, Enums.Resource.WORKFLOW, id, uuid, studyId, studyUuid, auditParams,
                     new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
             return insert;
         } catch (CatalogException e) {
-            auditManager.auditUpdate(organizationId, userId, Enums.Resource.WORKFLOW, id, uuid, "", "", auditParams,
+            auditManager.auditUpdate(organizationId, userId, Enums.Resource.WORKFLOW, id, uuid, studyId, studyUuid, auditParams,
                     new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
             throw e;
         }
     }
 
-    public OpenCGAResult<Workflow> get(String workflow, QueryOptions queryOptions, String token) throws CatalogException {
-        return get(Collections.singletonList(workflow), queryOptions, false, token);
+    @Override
+    public DBIterator<Workflow> iterator(String studyStr, Query query, QueryOptions options, String token) throws CatalogException {
+        return null;
     }
 
-    public OpenCGAResult<Workflow> get(List<String> workflowList, QueryOptions queryOptions, boolean ignoreException, String token)
+    @Override
+    public OpenCGAResult<Workflow> search(String studyId, Query query, QueryOptions options, String token) throws CatalogException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<?> distinct(String studyId, List<String> fields, Query query, String token) throws CatalogException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult<Workflow> count(String studyId, Query query, String token) throws CatalogException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult delete(String studyStr, List<String> ids, QueryOptions options, String token) throws CatalogException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult delete(String studyStr, Query query, QueryOptions options, String token) throws CatalogException {
+        return null;
+    }
+
+    @Override
+    public OpenCGAResult rank(String studyStr, Query query, String field, int numResults, boolean asc, String token)
             throws CatalogException {
-        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
-        String organizationId = tokenPayload.getOrganization();
-        String userId = tokenPayload.getUserId();
+        return null;
+    }
 
-        ObjectMap auditParams = new ObjectMap()
-                .append("workflowList", workflowList)
-                .append("queryOptions", queryOptions)
-                .append("ignoreException", ignoreException)
-                .append("token", token);
-        String operationUuid = UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.AUDIT);
-        auditManager.initAuditBatch(operationUuid);
-        QueryOptions options = queryOptions != null ? new QueryOptions(queryOptions) : new QueryOptions();
-        try {
-            OpenCGAResult<Workflow> result = OpenCGAResult.empty(Workflow.class);
-            options.remove(QueryOptions.LIMIT);
-            InternalGetDataResult<Workflow> responseResult = internalGet(organizationId, workflowList, null, options, userId,
-                    ignoreException);
-
-            Map<String, InternalGetDataResult<Workflow>.Missing> missingMap = new HashMap<>();
-            if (responseResult.getMissing() != null) {
-                missingMap = responseResult.getMissing().stream()
-                        .collect(Collectors.toMap(InternalGetDataResult.Missing::getId, Function.identity()));
-            }
+    @Override
+    public OpenCGAResult groupBy(@Nullable String studyStr, Query query, List<String> fields, QueryOptions options, String token)
+            throws CatalogException {
+        return null;
+    }
 
-            List<List<Workflow>> versionedResults = responseResult.getVersionedResults();
-            for (int i = 0; i < versionedResults.size(); i++) {
-                String entryId = workflowList.get(i);
-                if (versionedResults.get(i).isEmpty()) {
-                    Event event = new Event(Event.Type.ERROR, entryId, missingMap.get(entryId).getErrorMsg());
-                    // Missing
-                    result.getEvents().add(event);
-                } else {
-                    int size = versionedResults.get(i).size();
-                    result.append(new OpenCGAResult<>(0, Collections.emptyList(), size, versionedResults.get(i), size));
-
-                    Workflow entry = versionedResults.get(i).get(0);
-                    auditManager.auditInfo(organizationId, operationUuid, userId, Enums.Resource.WORKFLOW, entry.getId(), entry.getUuid(),
-                            "", "", auditParams, new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
-                }
+    private WorkflowDBAdaptor.QueryParams getFieldFilter(List<String> idList) throws CatalogException {
+        WorkflowDBAdaptor.QueryParams idQueryParam = null;
+        for (String entry : idList) {
+            WorkflowDBAdaptor.QueryParams param = ID;
+            if (UuidUtils.isOpenCgaUuid(entry)) {
+                param = UUID;
             }
+            if (idQueryParam == null) {
+                idQueryParam = param;
+            }
+            if (idQueryParam != param) {
+                throw new CatalogException("Found uuids and ids in the same query. Please, choose one or do two different queries.");
+            }
+        }
+        return idQueryParam;
+    }
 
-            return result;
-        } catch (CatalogException e) {
-            for (String entryId : workflowList) {
-                auditManager.auditInfo(organizationId, operationUuid, userId, Enums.Resource.WORKFLOW, entryId, "", "", "",
-                        auditParams, new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+    private void validateNewWorkflow(Workflow workflow) throws CatalogParameterException {
+        ParamUtils.checkIdentifier(workflow.getId(), ID.key());
+        ParamUtils.checkObj(workflow.getType(), TYPE.key());
+        workflow.setScripts(workflow.getScripts() != null ? workflow.getScripts() : Collections.emptyList());
+        boolean main = false;
+        for (WorkflowScript script : workflow.getScripts()) {
+            ParamUtils.checkIdentifier(script.getFilename(), SCRIPTS.key() + ".id");
+            ParamUtils.checkParameter(script.getContent(), SCRIPTS.key() + ".content");
+            if (script.isMain()) {
+                if (main) {
+                    throw new CatalogParameterException("More than one main script found.");
+                }
+                main = script.isMain();
             }
-            throw e;
-        } finally {
-            auditManager.finishAuditBatch(organizationId, operationUuid);
         }
+        if (CollectionUtils.isNotEmpty(workflow.getScripts()) && !main) {
+            throw new CatalogParameterException("No main script found.");
+        }
+        workflow.setDocker(workflow.getDocker() != null ? workflow.getDocker() : new WorkflowRepository(""));
+        if (StringUtils.isEmpty(workflow.getDocker().getImage()) && CollectionUtils.isEmpty(workflow.getScripts())) {
+            throw new CatalogParameterException("No docker image or scripts found.");
+        }
+
+        workflow.setName(ParamUtils.defaultString(workflow.getName(), workflow.getId()));
+        workflow.setDescription(ParamUtils.defaultString(workflow.getDescription(), ""));
+        workflow.setUuid(UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.WORKFLOW));
+        workflow.setVersion(1);
+        workflow.setCreationDate(ParamUtils.checkDateOrGetCurrentDate(workflow.getCreationDate(), CREATION_DATE.key()));
+        workflow.setModificationDate(ParamUtils.checkDateOrGetCurrentDate(workflow.getModificationDate(), MODIFICATION_DATE.key()));
+        workflow.setAttributes(ParamUtils.defaultObject(workflow.getAttributes(), Collections.emptyMap()));
     }
 
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index 03e1d83125c..213c65c11e1 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -309,8 +309,10 @@ public class FieldConstants {
     // Workflow
     //Sample
     public static final String WORKFLOW_ID_DESCRIPTION = "Workflow ID.";
+    public static final String WORKFLOW_NAME_DESCRIPTION = "Workflow name.";
     public static final String WORKFLOW_TYPE_DESCRIPTION = "Workflow type. Valid values: NEXTFLOW.";
-    public static final String WORKFLOW_COMMAND_LINE_DESCRIPTION = "Workflow command line.";
+    public static final String WORKFLOW_DOCKER_DESCRIPTION = "Workflow docker image to execute. If any, providing a list of scripts will"
+            + " not be mandatory.";
     public static final String WORKFLOW_SCRIPTS_DESCRIPTION = "List of scripts used by the Workflow.";
     public static final String WORKFLOW_SOMATIC_DESCRIPTION = "Describes if the sample is somatic or not .";
     public static final String WORKFLOW_INDIVIDUAL_ID_DESCRIPTION = "Individual id of the sample.";
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/study/StudyPermissions.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/study/StudyPermissions.java
index b7dba9c36de..8c23fdf813f 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/study/StudyPermissions.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/study/StudyPermissions.java
@@ -9,6 +9,7 @@
 import org.opencb.opencga.core.models.job.JobPermissions;
 import org.opencb.opencga.core.models.panel.PanelPermissions;
 import org.opencb.opencga.core.models.sample.SamplePermissions;
+import org.opencb.opencga.core.models.workflow.WorkflowPermissions;
 
 import java.util.*;
 
@@ -21,6 +22,7 @@ public class StudyPermissions {
     public static final int DISEASE_PANEL = 7;
     public static final int FAMILY = 8;
     public static final int CLINICAL_ANALYSIS = 9;
+    public static final int WORKFLOW = 10;
 
     // Study Permissions
     public enum Permissions {
@@ -109,7 +111,12 @@ public enum Permissions {
         WRITE_CLINICAL_ANNOTATIONS(Arrays.asList(VIEW_CLINICAL_ANALYSIS, VIEW_CLINICAL_ANNOTATIONS),
                 ClinicalAnalysisPermissions.WRITE_ANNOTATIONS.name(), CLINICAL_ANALYSIS),
         DELETE_CLINICAL_ANNOTATIONS(Arrays.asList(VIEW_CLINICAL_ANALYSIS, VIEW_CLINICAL_ANNOTATIONS, WRITE_CLINICAL_ANNOTATIONS),
-                ClinicalAnalysisPermissions.DELETE_ANNOTATIONS.name(), CLINICAL_ANALYSIS);
+                ClinicalAnalysisPermissions.DELETE_ANNOTATIONS.name(), CLINICAL_ANALYSIS),
+
+        // WORKFLOWS
+        VIEW_WORKFLOWS(Collections.emptyList(), WorkflowPermissions.VIEW.name(), WORKFLOW),
+        WRITE_WORKFLOWS(Collections.singletonList(VIEW_WORKFLOWS), WorkflowPermissions.WRITE.name(), WORKFLOW),
+        DELETE_WORKFLOWS(Arrays.asList(VIEW_WORKFLOWS, WRITE_WORKFLOWS), WorkflowPermissions.DELETE.name(), WORKFLOW);
 
         private final static Map<String, Permissions> map;
 
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index b9d37ac36c7..4a6f5d27898 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -2,12 +2,12 @@
 
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
-import org.opencb.opencga.core.models.PrivateFields;
+import org.opencb.opencga.core.models.PrivateStudyUid;
 
 import java.util.List;
 import java.util.Map;
 
-public class Workflow extends PrivateFields {
+public class Workflow extends PrivateStudyUid {
 
     @DataField(id = "id", required = true, indexed = true, unique = true, immutable = true,
             description = FieldConstants.WORKFLOW_ID_DESCRIPTION)
@@ -17,6 +17,9 @@ public class Workflow extends PrivateFields {
             description = FieldConstants.GENERIC_UUID_DESCRIPTION)
     private String uuid;
 
+    @DataField(id = "name", description = FieldConstants.GENERIC_UUID_DESCRIPTION)
+    private String name;
+
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
@@ -27,11 +30,11 @@ public class Workflow extends PrivateFields {
     @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
     private Type type;
 
-    @DataField(id = "commandLine", description = FieldConstants.WORKFLOW_COMMAND_LINE_DESCRIPTION)
-    private String commandLine;
+    @DataField(id = "docker", description = FieldConstants.WORKFLOW_DOCKER_DESCRIPTION)
+    private WorkflowRepository docker;
 
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
-    private List<Script> scripts;
+    private List<WorkflowScript> scripts;
 
     @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
@@ -49,13 +52,13 @@ public enum Type {
     public Workflow() {
     }
 
-    public Workflow(String id, String description, int version, Type type, String commandLine, List<Script> scripts, String creationDate,
-                    String modificationDate, Map<String, Object> attributes) {
+    public Workflow(String id, String name, String description, Type type, WorkflowRepository docker, List<WorkflowScript> scripts,
+                    String creationDate, String modificationDate, Map<String, Object> attributes) {
         this.id = id;
+        this.name = name;
         this.description = description;
-        this.version = version;
         this.type = type;
-        this.commandLine = commandLine;
+        this.docker = docker;
         this.scripts = scripts;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
@@ -67,10 +70,11 @@ public String toString() {
         final StringBuilder sb = new StringBuilder("Workflow{");
         sb.append("id='").append(id).append('\'');
         sb.append(", uuid='").append(uuid).append('\'');
+        sb.append(", name='").append(name).append('\'');
         sb.append(", description='").append(description).append('\'');
         sb.append(", version=").append(version);
         sb.append(", type=").append(type);
-        sb.append(", commandLine='").append(commandLine).append('\'');
+        sb.append(", docker='").append(docker).append('\'');
         sb.append(", scripts=").append(scripts);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
@@ -97,6 +101,15 @@ public Workflow setUuid(String uuid) {
         return this;
     }
 
+    public String getName() {
+        return name;
+    }
+
+    public Workflow setName(String name) {
+        this.name = name;
+        return this;
+    }
+
     public String getDescription() {
         return description;
     }
@@ -124,20 +137,20 @@ public Workflow setType(Type type) {
         return this;
     }
 
-    public String getCommandLine() {
-        return commandLine;
+    public WorkflowRepository getDocker() {
+        return docker;
     }
 
-    public Workflow setCommandLine(String commandLine) {
-        this.commandLine = commandLine;
+    public Workflow setDocker(WorkflowRepository docker) {
+        this.docker = docker;
         return this;
     }
 
-    public List<Script> getScripts() {
+    public List<WorkflowScript> getScripts() {
         return scripts;
     }
 
-    public Workflow setScripts(List<Script> scripts) {
+    public Workflow setScripts(List<WorkflowScript> scripts) {
         this.scripts = scripts;
         return this;
     }
@@ -168,46 +181,4 @@ public Workflow setAttributes(Map<String, Object> attributes) {
         this.attributes = attributes;
         return this;
     }
-
-    public static class Script {
-
-        private String id;
-        private String content;
-
-        public Script() {
-        }
-
-        public Script(String id, String content) {
-            this.id = id;
-            this.content = content;
-        }
-
-        @Override
-        public String toString() {
-            final StringBuilder sb = new StringBuilder("Script{");
-            sb.append("id='").append(id).append('\'');
-            sb.append(", content='").append(content).append('\'');
-            sb.append('}');
-            return sb.toString();
-        }
-
-        public String getId() {
-            return id;
-        }
-
-        public Script setId(String id) {
-            this.id = id;
-            return this;
-        }
-
-        public String getContent() {
-            return content;
-        }
-
-        public Script setContent(String content) {
-            this.content = content;
-            return this;
-        }
-    }
-
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowAclEntryList.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowAclEntryList.java
new file mode 100644
index 00000000000..b4234b0ee03
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowAclEntryList.java
@@ -0,0 +1,6 @@
+package org.opencb.opencga.core.models.workflow;
+
+import org.opencb.opencga.core.models.AclEntryList;
+
+public class WorkflowAclEntryList  extends AclEntryList<WorkflowPermissions> {
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
index d5777615030..4c2948cd196 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -12,17 +12,20 @@ public class WorkflowCreateParams {
             description = FieldConstants.WORKFLOW_ID_DESCRIPTION)
     private String id;
 
+    @DataField(id = "name", description = FieldConstants.WORKFLOW_NAME_DESCRIPTION)
+    private String name;
+
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
 //    @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
 //    private Workflow.Type type;
 
-    @DataField(id = "commandLine", description = FieldConstants.WORKFLOW_COMMAND_LINE_DESCRIPTION)
-    private String commandLine;
+    @DataField(id = "docker", description = FieldConstants.WORKFLOW_DOCKER_DESCRIPTION)
+    private WorkflowRepository docker;
 
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
-    private List<Workflow.Script> scripts;
+    private List<WorkflowScript> scripts;
 
     @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
@@ -36,11 +39,12 @@ public class WorkflowCreateParams {
     public WorkflowCreateParams() {
     }
 
-    public WorkflowCreateParams(String id, String description, String commandLine, List<Workflow.Script> scripts,
+    public WorkflowCreateParams(String id, String name, String description, WorkflowRepository docker, List<WorkflowScript> scripts,
                                 String creationDate, String modificationDate, Map<String, Object> attributes) {
         this.id = id;
+        this.name = name;
         this.description = description;
-        this.commandLine = commandLine;
+        this.docker = docker;
         this.scripts = scripts;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
@@ -51,8 +55,9 @@ public WorkflowCreateParams(String id, String description, String commandLine, L
     public String toString() {
         final StringBuilder sb = new StringBuilder("WorkflowCreateParams{");
         sb.append("id='").append(id).append('\'');
+        sb.append(", name='").append(name).append('\'');
         sb.append(", description='").append(description).append('\'');
-        sb.append(", commandLine='").append(commandLine).append('\'');
+        sb.append(", docker=").append(docker);
         sb.append(", scripts=").append(scripts);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
@@ -62,7 +67,7 @@ public String toString() {
     }
 
     public Workflow toWorkflow() {
-        return new Workflow(id, description, 0, Workflow.Type.NEXTFLOW, commandLine, scripts, creationDate, modificationDate, attributes);
+        return new Workflow(id, name, description, Workflow.Type.NEXTFLOW, docker, scripts, creationDate, modificationDate, attributes);
     }
 
     public String getId() {
@@ -74,6 +79,15 @@ public WorkflowCreateParams setId(String id) {
         return this;
     }
 
+    public String getName() {
+        return name;
+    }
+
+    public WorkflowCreateParams setName(String name) {
+        this.name = name;
+        return this;
+    }
+
     public String getDescription() {
         return description;
     }
@@ -83,20 +97,20 @@ public WorkflowCreateParams setDescription(String description) {
         return this;
     }
 
-    public String getCommandLine() {
-        return commandLine;
+    public WorkflowRepository getDocker() {
+        return docker;
     }
 
-    public WorkflowCreateParams setCommandLine(String commandLine) {
-        this.commandLine = commandLine;
+    public WorkflowCreateParams setDocker(WorkflowRepository docker) {
+        this.docker = docker;
         return this;
     }
 
-    public List<Workflow.Script> getScripts() {
+    public List<WorkflowScript> getScripts() {
         return scripts;
     }
 
-    public WorkflowCreateParams setScripts(List<Workflow.Script> scripts) {
+    public WorkflowCreateParams setScripts(List<WorkflowScript> scripts) {
         this.scripts = scripts;
         return this;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowPermissions.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowPermissions.java
new file mode 100644
index 00000000000..3f14ccf1d94
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowPermissions.java
@@ -0,0 +1,30 @@
+package org.opencb.opencga.core.models.workflow;
+
+import java.util.*;
+
+public enum WorkflowPermissions {
+    NONE(Collections.emptyList()),
+    VIEW(Collections.emptyList()),
+    WRITE(Collections.singletonList(VIEW)),
+    DELETE(Arrays.asList(VIEW, WRITE));
+
+    private final List<WorkflowPermissions> implicitPermissions;
+
+    WorkflowPermissions(List<WorkflowPermissions> implicitPermissions) {
+        this.implicitPermissions = implicitPermissions;
+    }
+
+    public List<WorkflowPermissions> getImplicitPermissions() {
+        return implicitPermissions;
+    }
+
+    public List<WorkflowPermissions> getDependentPermissions() {
+        List<WorkflowPermissions> dependentPermissions = new LinkedList<>();
+        for (WorkflowPermissions permission : EnumSet.complementOf(EnumSet.of(this))) {
+            if (permission.getImplicitPermissions().contains(this)) {
+                dependentPermissions.add(permission);
+            }
+        }
+        return dependentPermissions;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepository.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepository.java
new file mode 100644
index 00000000000..c2a86cbacb7
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepository.java
@@ -0,0 +1,30 @@
+package org.opencb.opencga.core.models.workflow;
+
+public class WorkflowRepository {
+
+    private String image;
+
+    public WorkflowRepository() {
+    }
+
+    public WorkflowRepository(String image) {
+        this.image = image;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowRepository{");
+        sb.append("image='").append(image).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getImage() {
+        return image;
+    }
+
+    public WorkflowRepository setImage(String image) {
+        this.image = image;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowScript.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowScript.java
new file mode 100644
index 00000000000..3e5f40b50f1
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowScript.java
@@ -0,0 +1,61 @@
+package org.opencb.opencga.core.models.workflow;
+
+import org.opencb.commons.annotations.DataField;
+
+public class WorkflowScript {
+
+    @DataField(id = "filename", description = "File name")
+    private String filename;
+
+    @DataField(id = "content", description = "Script content")
+    private String content;
+
+    @DataField(id = "main", description = "Flag indicating if this script is the main one.")
+    private boolean main;
+
+    public WorkflowScript() {
+    }
+
+    public WorkflowScript(String filename, String content, boolean main) {
+        this.filename = filename;
+        this.content = content;
+        this.main = main;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowScript{");
+        sb.append("filename='").append(filename).append('\'');
+        sb.append(", content='").append(content).append('\'');
+        sb.append(", main=").append(main);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getFilename() {
+        return filename;
+    }
+
+    public WorkflowScript setFilename(String filename) {
+        this.filename = filename;
+        return this;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public WorkflowScript setContent(String content) {
+        this.content = content;
+        return this;
+    }
+
+    public boolean isMain() {
+        return main;
+    }
+
+    public WorkflowScript setMain(boolean main) {
+        this.main = main;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
index 5a37216dd7f..e89a2ab4350 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
@@ -8,14 +8,17 @@
 
 public class WorkflowUpdateParams {
 
+    @DataField(id = "name", description = FieldConstants.WORKFLOW_NAME_DESCRIPTION)
+    private String name;
+
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
-    @DataField(id = "commandLine", description = FieldConstants.WORKFLOW_COMMAND_LINE_DESCRIPTION)
-    private String commandLine;
+    @DataField(id = "docker", description = FieldConstants.WORKFLOW_DOCKER_DESCRIPTION)
+    private WorkflowRepository docker;
 
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
-    private List<Workflow.Script> scripts;
+    private List<WorkflowScript> scripts;
 
     @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
@@ -29,10 +32,11 @@ public class WorkflowUpdateParams {
     public WorkflowUpdateParams() {
     }
 
-    public WorkflowUpdateParams(String description, String commandLine, List<Workflow.Script> scripts,
-                                String creationDate, String modificationDate, Map<String, Object> attributes) {
+    public WorkflowUpdateParams(String name, String description, WorkflowRepository docker, List<WorkflowScript> scripts, String creationDate,
+                                String modificationDate, Map<String, Object> attributes) {
+        this.name = name;
         this.description = description;
-        this.commandLine = commandLine;
+        this.docker = docker;
         this.scripts = scripts;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
@@ -42,8 +46,9 @@ public WorkflowUpdateParams(String description, String commandLine, List<Workflo
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("WorkflowUpdateParams{");
-        sb.append("description='").append(description).append('\'');
-        sb.append(", commandLine='").append(commandLine).append('\'');
+        sb.append("name='").append(name).append('\'');
+        sb.append(", description='").append(description).append('\'');
+        sb.append(", docker=").append(docker);
         sb.append(", scripts=").append(scripts);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
@@ -52,6 +57,15 @@ public String toString() {
         return sb.toString();
     }
 
+    public String getName() {
+        return name;
+    }
+
+    public WorkflowUpdateParams setName(String name) {
+        this.name = name;
+        return this;
+    }
+
     public String getDescription() {
         return description;
     }
@@ -61,20 +75,20 @@ public WorkflowUpdateParams setDescription(String description) {
         return this;
     }
 
-    public String getCommandLine() {
-        return commandLine;
+    public WorkflowRepository getDocker() {
+        return docker;
     }
 
-    public WorkflowUpdateParams setCommandLine(String commandLine) {
-        this.commandLine = commandLine;
+    public WorkflowUpdateParams setDocker(WorkflowRepository docker) {
+        this.docker = docker;
         return this;
     }
 
-    public List<Workflow.Script> getScripts() {
+    public List<WorkflowScript> getScripts() {
         return scripts;
     }
 
-    public WorkflowUpdateParams setScripts(List<Workflow.Script> scripts) {
+    public WorkflowUpdateParams setScripts(List<WorkflowScript> scripts) {
         this.scripts = scripts;
         return this;
     }

From 0bb262d91276cda9e83414128178e9321a0da21f Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 2 Sep 2024 13:11:45 +0200
Subject: [PATCH 07/99] server: add new workflow web services, #TASK-6445

---
 .../app/misc/clients/r_client_generator.py    |   1 +
 .../app/misc/clients/rest_client_generator.py |   1 +
 .../CatalogAuthorizationManager.java          |  33 +++
 .../mongodb/AuthorizationMongoDBAdaptor.java  |  11 +-
 .../db/mongodb/WorkflowMongoDBAdaptor.java    |  91 +++++--
 .../catalog/managers/WorkflowManager.java     | 238 ++++++++++++++++-
 opencga-client/src/main/R/R/AllGenerics.R     |   5 +
 .../src/main/R/R/Workflow-methods.R           | 136 ++++++++++
 .../client/rest/clients/WorkflowClient.java   | 209 +++++++++++++++
 .../src/main/javascript/Workflow.js           | 170 ++++++++++++
 .../pyopencga/rest_clients/workflow_client.py | 207 +++++++++++++++
 .../opencga/core/api/ParamConstants.java      |  16 ++
 .../generator/ClientsGeneratorMain.java       |   1 +
 .../opencga/server/rest/MetaWSServer.java     |   1 +
 .../opencga/server/rest/WorkflowWSServer.java | 243 ++++++++++++++++++
 .../server/generator/RestApiParserTest.java   |   1 +
 16 files changed, 1330 insertions(+), 34 deletions(-)
 create mode 100644 opencga-client/src/main/R/R/Workflow-methods.R
 create mode 100644 opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
 create mode 100644 opencga-client/src/main/javascript/Workflow.js
 create mode 100644 opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
 create mode 100644 opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java

diff --git a/opencga-app/app/misc/clients/r_client_generator.py b/opencga-app/app/misc/clients/r_client_generator.py
index 2d2a4840a97..0ba30d3e5a6 100644
--- a/opencga-app/app/misc/clients/r_client_generator.py
+++ b/opencga-app/app/misc/clients/r_client_generator.py
@@ -17,6 +17,7 @@ def __init__(self, server_url, output_dir):
             'Studies': 'Study',
             'Files': 'File',
             'Jobs': 'Job',
+            'Workflows': 'Workflow',
             'Samples': 'Sample',
             'Individuals': 'Individual',
             'Families': 'Family',
diff --git a/opencga-app/app/misc/clients/rest_client_generator.py b/opencga-app/app/misc/clients/rest_client_generator.py
index 53ed2bdfd8f..5863dc717ac 100644
--- a/opencga-app/app/misc/clients/rest_client_generator.py
+++ b/opencga-app/app/misc/clients/rest_client_generator.py
@@ -41,6 +41,7 @@ def __init__(self, rest_api_file, output_dir):
             'Studies': 'Study',
             'Files': 'File',
             'Jobs': 'Job',
+            'Workflows': 'Workflow',
             'Samples': 'Sample',
             'Individuals': 'Individual',
             'Families': 'Family',
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/CatalogAuthorizationManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/CatalogAuthorizationManager.java
index b3374341da9..e8b18e4943a 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/CatalogAuthorizationManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/auth/authorization/CatalogAuthorizationManager.java
@@ -754,6 +754,17 @@ private void setDependentPermissions(List<CatalogAclParams> aclParams) throws Ca
                                 .collect(Collectors.toSet())
                         );
                         break;
+                    case WORKFLOW:
+                        allPermissions.addAll(aclParam.getPermissions()
+                                .stream()
+                                .map(WorkflowPermissions::valueOf)
+                                .map(WorkflowPermissions::getDependentPermissions)
+                                .flatMap(List::stream)
+                                .collect(Collectors.toSet())
+                                .stream().map(Enum::name)
+                                .collect(Collectors.toSet())
+                        );
+                        break;
                     default:
                         throw new CatalogAuthorizationException("Unexpected resource '" + aclParam.getResource() + "'");
                 }
@@ -868,6 +879,17 @@ private void setImplicitPermissions(List<CatalogAclParams> aclParams) throws Cat
                             .collect(Collectors.toSet())
                     );
                     break;
+                case WORKFLOW:
+                    allPermissions.addAll(aclParam.getPermissions()
+                            .stream()
+                            .map(WorkflowPermissions::valueOf)
+                            .map(WorkflowPermissions::getImplicitPermissions)
+                            .flatMap(List::stream)
+                            .collect(Collectors.toSet())
+                            .stream().map(Enum::name)
+                            .collect(Collectors.toSet())
+                    );
+                    break;
                 default:
                     throw new CatalogAuthorizationException("Unexpected resource '" + aclParam.getResource() + "'");
             }
@@ -980,6 +1002,17 @@ private List<String> getImplicitPermissions(List<String> permissions, Enums.Reso
                         .collect(Collectors.toSet())
                 );
                 break;
+            case WORKFLOW:
+                allPermissions.addAll(permissions
+                        .stream()
+                        .map(WorkflowPermissions::valueOf)
+                        .map(WorkflowPermissions::getImplicitPermissions)
+                        .flatMap(List::stream)
+                        .collect(Collectors.toSet())
+                        .stream().map(Enum::name)
+                        .collect(Collectors.toSet())
+                );
+                break;
             default:
                 throw new CatalogAuthorizationException("Unexpected resource '" + resource + "'");
         }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/AuthorizationMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/AuthorizationMongoDBAdaptor.java
index 445c1c6047a..5b70e7c9d97 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/AuthorizationMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/AuthorizationMongoDBAdaptor.java
@@ -135,6 +135,7 @@ private void validateEntry(Enums.Resource entry) throws CatalogDBException {
             case FAMILY:
             case CLINICAL_ANALYSIS:
             case CLINICAL:
+            case WORKFLOW:
                 return;
             default:
                 throw new CatalogDBException("Unexpected parameter received. " + entry + " has been received.");
@@ -785,6 +786,7 @@ public OpenCGAResult resetMembersFromAllEntries(long studyId, List<String> membe
             removePermissions(clientSession, studyId, members, Enums.Resource.DISEASE_PANEL);
             removePermissions(clientSession, studyId, members, Enums.Resource.FAMILY);
             removePermissions(clientSession, studyId, members, Enums.Resource.CLINICAL_ANALYSIS);
+            removePermissions(clientSession, studyId, members, Enums.Resource.WORKFLOW);
             removeFromMembers(clientSession, Collections.singletonList(studyId), members, null, Enums.Resource.STUDY);
 
             return endWrite(tmpStartTime, -1, -1, null);
@@ -1101,6 +1103,8 @@ private Bson parseQuery(Query query, Document rawQuery, Enums.Resource entry) th
             case CLINICAL_ANALYSIS:
             case CLINICAL:
                 return dbAdaptorFactory.getClinicalAnalysisDBAdaptor().parseQuery(query, rawQuery);
+            case WORKFLOW:
+                return dbAdaptorFactory.getWorkflowDBAdaptor().parseQuery(query, rawQuery);
             default:
                 throw new CatalogException("Unexpected parameter received. " + entry + " has been received.");
         }
@@ -1185,6 +1189,8 @@ private MongoDBCollection getMainCollection(Enums.Resource resource) throws Cata
             case CLINICAL_ANALYSIS:
             case CLINICAL:
                 return dbAdaptorFactory.getClinicalAnalysisDBAdaptor().getCollection();
+            case WORKFLOW:
+                return dbAdaptorFactory.getWorkflowDBAdaptor().getCollection();
             default:
                 throw new CatalogDBException("Unexpected resource '" + resource + "' parameter received.");
         }
@@ -1200,6 +1206,8 @@ private MongoDBCollection getArchiveCollection(Enums.Resource resource) throws C
                 return dbAdaptorFactory.getCatalogPanelDBAdaptor().getPanelArchiveCollection();
             case FAMILY:
                 return dbAdaptorFactory.getCatalogFamilyDBAdaptor().getArchiveFamilyCollection();
+            case WORKFLOW:
+                return dbAdaptorFactory.getWorkflowDBAdaptor().getArchiveCollection();
             default:
                 throw new CatalogDBException("Unexpected resource '" + resource + "' parameter received.");
         }
@@ -1207,6 +1215,7 @@ private MongoDBCollection getArchiveCollection(Enums.Resource resource) throws C
 
     private boolean hasArchiveCollection(Enums.Resource resource) {
         return resource == Enums.Resource.INDIVIDUAL || resource == Enums.Resource.SAMPLE || resource == Enums.Resource.DISEASE_PANEL
-                || resource == Enums.Resource.FAMILY;
+                || resource == Enums.Resource.FAMILY || resource == Enums.Resource.CLINICAL || resource == Enums.Resource.CLINICAL_ANALYSIS
+                || resource == Enums.Resource.WORKFLOW;
     }
 }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index 522011fa07c..3da0bb5232d 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -17,11 +17,12 @@
 import org.opencb.opencga.catalog.exceptions.CatalogDBException;
 import org.opencb.opencga.catalog.exceptions.CatalogParameterException;
 import org.opencb.opencga.catalog.utils.Constants;
-import org.opencb.opencga.catalog.utils.ParamUtils;
+import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Configuration;
+import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.workflow.Workflow;
-import org.opencb.opencga.core.models.workflow.WorkflowScript;
+import org.opencb.opencga.core.models.workflow.WorkflowPermissions;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.slf4j.LoggerFactory;
 
@@ -31,6 +32,7 @@
 import java.util.stream.Collectors;
 
 import static org.opencb.opencga.catalog.db.api.ClinicalAnalysisDBAdaptor.QueryParams.MODIFICATION_DATE;
+import static org.opencb.opencga.catalog.db.mongodb.AuthorizationMongoDBUtils.getQueryForAuthorisedEntries;
 import static org.opencb.opencga.catalog.db.mongodb.MongoDBUtils.*;
 
 public class WorkflowMongoDBAdaptor extends CatalogMongoDBAdaptor implements WorkflowDBAdaptor {
@@ -54,6 +56,14 @@ public WorkflowMongoDBAdaptor(MongoDBCollection workflowCollection, MongoDBColle
         this.workflowConverter = new WorkflowConverter();
     }
 
+    public MongoDBCollection getCollection() {
+        return workflowCollection;
+    }
+
+    public MongoDBCollection getArchiveCollection() {
+        return archiveWorkflowCollection;
+    }
+
     Workflow insert(ClientSession clientSession, long studyUid, Workflow workflow) throws CatalogDBException {
         dbAdaptorFactory.getCatalogStudyDBAdaptor().checkId(studyUid);
         if (StringUtils.isEmpty(workflow.getId())) {
@@ -316,29 +326,32 @@ private UpdateDocument parseAndValidateUpdateParams(ObjectMap parameters, QueryO
         final String[] acceptedMapParams = {QueryParams.ATTRIBUTES.key()};
         filterMapParams(parameters, document.getSet(), acceptedMapParams);
 
-        // Check if the tags exist.
-        if (parameters.containsKey(QueryParams.SCRIPTS.key())) {
-            List<WorkflowScript> scriptList = parameters.getAsList(QueryParams.SCRIPTS.key(), WorkflowScript.class);
-
-            if (!scriptList.isEmpty()) {
-                Map<String, Object> actionMap = queryOptions.getMap(Constants.ACTIONS, new HashMap<>());
-                ParamUtils.BasicUpdateAction operation =
-                        ParamUtils.BasicUpdateAction.from(actionMap, QueryParams.SCRIPTS.key(), ParamUtils.BasicUpdateAction.ADD);
-                switch (operation) {
-                    case SET:
-                        document.getSet().put(QueryParams.SCRIPTS.key(), scriptList);
-                        break;
-                    case REMOVE:
-                        document.getPullAll().put(QueryParams.SCRIPTS.key(), scriptList);
-                        break;
-                    case ADD:
-                        document.getAddToSet().put(QueryParams.SCRIPTS.key(), scriptList);
-                        break;
-                    default:
-                        throw new IllegalArgumentException("Unknown update action " + operation);
-                }
-            }
-        }
+        final String[] acceptedListParams = {QueryParams.SCRIPTS.key()};
+        filterObjectParams(parameters, document.getSet(), acceptedListParams);
+
+//        // Check if the scripts exist.
+//        if (parameters.containsKey(QueryParams.SCRIPTS.key())) {
+//            List<WorkflowScript> scriptList = parameters.getAsList(QueryParams.SCRIPTS.key(), WorkflowScript.class);
+//
+//            if (!scriptList.isEmpty()) {
+//                Map<String, Object> actionMap = queryOptions.getMap(Constants.ACTIONS, new HashMap<>());
+//                ParamUtils.BasicUpdateAction operation =
+//                        ParamUtils.BasicUpdateAction.from(actionMap, QueryParams.SCRIPTS.key(), ParamUtils.BasicUpdateAction.ADD);
+//                switch (operation) {
+//                    case SET:
+//                        document.getSet().put(QueryParams.SCRIPTS.key(), scriptList);
+//                        break;
+//                    case REMOVE:
+//                        document.getPullAll().put(QueryParams.SCRIPTS.key(), scriptList);
+//                        break;
+//                    case ADD:
+//                        document.getAddToSet().put(QueryParams.SCRIPTS.key(), scriptList);
+//                        break;
+//                    default:
+//                        throw new IllegalArgumentException("Unknown update action " + operation);
+//                }
+//            }
+//        }
 
         if (!document.toFinalUpdateDocument().isEmpty()) {
             String time = TimeUtils.getTime();
@@ -408,12 +421,38 @@ private MongoDBIterator<Document> getMongoCursor(ClientSession clientSession, Qu
 
 
     private Bson parseQuery(Query query) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return parseQuery(query, null);
+        return parseQuery(query, null, null);
     }
 
     private Bson parseQuery(Query query, String user) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return parseQuery(query, null, user);
+    }
+
+    protected Bson parseQuery(Query query, Document extraQuery)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        return parseQuery(query, extraQuery, null);
+    }
+
+    protected Bson parseQuery(Query query, Document extraQuery, String user)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
         List<Bson> andBsonList = new ArrayList<>();
 
+        if (query.containsKey(QueryParams.STUDY_UID.key())
+                && (StringUtils.isNotEmpty(user) || query.containsKey(ParamConstants.ACL_PARAM))) {
+            Document studyDocument = getStudyDocument(null, query.getLong(QueryParams.STUDY_UID.key()));
+            boolean simplifyPermissions = simplifyPermissions();
+
+            if (query.containsKey(ParamConstants.ACL_PARAM)) {
+                andBsonList.addAll(AuthorizationMongoDBUtils.parseAclQuery(studyDocument, query, Enums.Resource.WORKFLOW, user,
+                        simplifyPermissions));
+            } else {
+                    andBsonList.add(getQueryForAuthorisedEntries(studyDocument, user, WorkflowPermissions.VIEW.name(),
+                            Enums.Resource.WORKFLOW, simplifyPermissions));
+            }
+
+            query.remove(ParamConstants.ACL_PARAM);
+        }
+
         Query queryCopy = new Query(query);
 //        queryCopy.remove(WorkflowDBAdaptor.QueryParams.DELETED.key());
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index b50dd4b96c4..da1e10b0809 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -3,9 +3,11 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
+import org.opencb.commons.datastore.core.Event;
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.Query;
 import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.commons.datastore.core.result.Error;
 import org.opencb.commons.utils.ListUtils;
 import org.opencb.opencga.catalog.auth.authorization.AuthorizationManager;
 import org.opencb.opencga.catalog.db.DBAdaptorFactory;
@@ -23,25 +25,24 @@
 import org.opencb.opencga.catalog.utils.UuidUtils;
 import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.config.Configuration;
+import org.opencb.opencga.core.models.AclEntryList;
+import org.opencb.opencga.core.models.AclParams;
 import org.opencb.opencga.core.models.JwtPayload;
 import org.opencb.opencga.core.models.audit.AuditRecord;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.models.study.StudyPermissions;
-import org.opencb.opencga.core.models.workflow.Workflow;
-import org.opencb.opencga.core.models.workflow.WorkflowRepository;
-import org.opencb.opencga.core.models.workflow.WorkflowScript;
-import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
+import org.opencb.opencga.core.models.workflow.*;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import javax.annotation.Nullable;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
+import java.util.*;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
+import static org.opencb.opencga.catalog.auth.authorization.CatalogAuthorizationManager.checkPermissions;
 import static org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor.QueryParams.*;
 import static org.opencb.opencga.core.common.JacksonUtils.getUpdateObjectMapper;
 
@@ -316,4 +317,227 @@ private void validateNewWorkflow(Workflow workflow) throws CatalogParameterExcep
         workflow.setAttributes(ParamUtils.defaultObject(workflow.getAttributes(), Collections.emptyMap()));
     }
 
+    // **************************   ACLs  ******************************** //
+    public OpenCGAResult<AclEntryList<WorkflowPermissions>> getAcls(String studyId, List<String> workflowList, String member,
+                                                                    boolean ignoreException, String token) throws CatalogException {
+        return getAcls(studyId, workflowList,
+                StringUtils.isNotEmpty(member) ? Collections.singletonList(member) : Collections.emptyList(), ignoreException, token);
+    }
+
+    public OpenCGAResult<AclEntryList<WorkflowPermissions>> getAcls(String studyStr, List<String> workflowList, List<String> members,
+                                                                  boolean ignoreException, String token) throws CatalogException {
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+        Study study = catalogManager.getStudyManager().resolveId(studyStr, userId, organizationId);
+
+        String operationId = UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.AUDIT);
+        ObjectMap auditParams = new ObjectMap()
+                .append("studyId", studyStr)
+                .append("workflowList", workflowList)
+                .append("members", members)
+                .append("ignoreException", ignoreException)
+                .append("token", token);
+
+        OpenCGAResult<AclEntryList<WorkflowPermissions>> workflowAcls = OpenCGAResult.empty();
+        Map<String, InternalGetDataResult.Missing> missingMap = new HashMap<>();
+        try {
+            auditManager.initAuditBatch(operationId);
+            InternalGetDataResult<Workflow> queryResult = internalGet(organizationId, study.getUid(), workflowList, INCLUDE_WORKFLOW_IDS,
+                    userId, ignoreException);
+
+            if (queryResult.getMissing() != null) {
+                missingMap = queryResult.getMissing().stream()
+                        .collect(Collectors.toMap(InternalGetDataResult.Missing::getId, Function.identity()));
+            }
+
+            List<Long> workflowUids = queryResult.getResults().stream().map(Workflow::getUid).collect(Collectors.toList());
+            if (CollectionUtils.isNotEmpty(members)) {
+                workflowAcls = authorizationManager.getAcl(organizationId, study.getUid(), workflowUids, members, Enums.Resource.WORKFLOW,
+                        WorkflowPermissions.class, userId);
+            } else {
+                workflowAcls = authorizationManager.getAcl(organizationId, study.getUid(), workflowUids, Enums.Resource.WORKFLOW,
+                        WorkflowPermissions.class, userId);
+            }
+
+            // Include non-existing samples to the result list
+            List<AclEntryList<WorkflowPermissions>> resultList = new ArrayList<>(workflowList.size());
+            List<Event> eventList = new ArrayList<>(missingMap.size());
+            int counter = 0;
+            for (String workflowId : workflowList) {
+                if (!missingMap.containsKey(workflowId)) {
+                    Workflow workflow = queryResult.getResults().get(counter);
+                    resultList.add(workflowAcls.getResults().get(counter));
+                    auditManager.audit(organizationId, operationId, userId, Enums.Action.FETCH_ACLS, Enums.Resource.WORKFLOW,
+                            workflow.getId(), workflow.getUuid(), study.getId(), study.getUuid(), auditParams,
+                            new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS), new ObjectMap());
+                    counter++;
+                } else {
+                    resultList.add(new AclEntryList<>());
+                    eventList.add(new Event(Event.Type.ERROR, workflowId, missingMap.get(workflowId).getErrorMsg()));
+                    auditManager.audit(organizationId, operationId, userId, Enums.Action.FETCH_ACLS, Enums.Resource.WORKFLOW, workflowId,
+                            "", study.getId(), study.getUuid(), auditParams, new AuditRecord.Status(AuditRecord.Status.Result.ERROR,
+                                    new Error(0, "", missingMap.get(workflowId).getErrorMsg())), new ObjectMap());
+                }
+            }
+            for (int i = 0; i < queryResult.getResults().size(); i++) {
+                workflowAcls.getResults().get(i).setId(queryResult.getResults().get(i).getId());
+            }
+            workflowAcls.setResults(resultList);
+            workflowAcls.setEvents(eventList);
+        } catch (CatalogException e) {
+            for (String workflowId : workflowList) {
+                auditManager.audit(organizationId, operationId, userId, Enums.Action.FETCH_ACLS, Enums.Resource.WORKFLOW, workflowId, "",
+                        study.getId(), study.getUuid(), auditParams, new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()),
+                        new ObjectMap());
+            }
+            if (!ignoreException) {
+                throw e;
+            } else {
+                for (String workflowId : workflowList) {
+                    Event event = new Event(Event.Type.ERROR, workflowId, e.getMessage());
+                    workflowAcls.append(new OpenCGAResult<>(0, Collections.singletonList(event), 0, Collections.emptyList(), 0));
+                }
+            }
+        } finally {
+            auditManager.finishAuditBatch(organizationId, operationId);
+        }
+
+        return workflowAcls;
+    }
+
+    public OpenCGAResult<AclEntryList<WorkflowPermissions>> updateAcl(String studyStr, List<String> workflowStringList, String memberList,
+                                                                      AclParams aclParams, ParamUtils.AclAction action, String token)
+            throws CatalogException {
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+        Study study = catalogManager.getStudyManager().resolveId(studyStr, userId, organizationId);
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("studyId", studyStr)
+                .append("workflowStringList", workflowStringList)
+                .append("memberList", memberList)
+                .append("aclParams", aclParams)
+                .append("action", action)
+                .append("token", token);
+        String operationId = UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.AUDIT);
+
+        List<String> members;
+        List<Workflow> workflowList;
+        List<String> permissions = Collections.emptyList();
+        try {
+            auditManager.initAuditBatch(operationId);
+
+            if (CollectionUtils.isEmpty(workflowStringList)) {
+                throw new CatalogException("Update ACL: No workflows provided to be updated.");
+            }
+            if (action == null) {
+                throw new CatalogException("Invalid action found. Please choose a valid action to be performed.");
+            }
+
+            if (StringUtils.isNotEmpty(aclParams.getPermissions())) {
+                permissions = Arrays.asList(aclParams.getPermissions().trim().replaceAll("\\s", "").split(","));
+                checkPermissions(permissions, WorkflowPermissions::valueOf);
+            }
+
+            workflowList = internalGet(organizationId, study.getUid(), workflowStringList, INCLUDE_WORKFLOW_IDS, userId, false)
+                    .getResults();
+            authorizationManager.checkCanAssignOrSeePermissions(organizationId, study.getUid(), userId);
+
+            // Validate that the members are actually valid members
+            if (memberList != null && !memberList.isEmpty()) {
+                members = Arrays.asList(memberList.split(","));
+            } else {
+                members = Collections.emptyList();
+            }
+            checkMembers(organizationId, study.getUid(), members);
+            authorizationManager.checkNotAssigningPermissionsToAdminsGroup(members);
+        } catch (CatalogException e) {
+            if (workflowStringList != null) {
+                for (String workflowId : workflowStringList) {
+                    auditManager.audit(organizationId, operationId, userId, Enums.Action.UPDATE_ACLS, Enums.Resource.WORKFLOW, workflowId,
+                            "", study.getId(), study.getUuid(), auditParams,
+                            new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()), new ObjectMap());
+                }
+            }
+            auditManager.finishAuditBatch(organizationId, operationId);
+            throw e;
+        }
+
+        OpenCGAResult<AclEntryList<WorkflowPermissions>> aclResultList = OpenCGAResult.empty();
+        int numProcessed = 0;
+        do {
+            List<Workflow> batchWorkflowList = new ArrayList<>();
+            while (numProcessed < Math.min(numProcessed + BATCH_OPERATION_SIZE, workflowList.size())) {
+                batchWorkflowList.add(workflowList.get(numProcessed));
+                numProcessed += 1;
+            }
+
+            List<Long> workflowUids = batchWorkflowList.stream().map(Workflow::getUid).collect(Collectors.toList());
+            List<String> workflowIds = batchWorkflowList.stream().map(Workflow::getId).collect(Collectors.toList());
+            List<AuthorizationManager.CatalogAclParams> aclParamsList = new ArrayList<>();
+            AuthorizationManager.CatalogAclParams.addToList(workflowUids, permissions, Enums.Resource.WORKFLOW, aclParamsList);
+
+            try {
+                switch (action) {
+                    case SET:
+                        authorizationManager.setAcls(organizationId, study.getUid(), members, aclParamsList);
+                        break;
+                    case ADD:
+                        authorizationManager.addAcls(organizationId, study.getUid(), members, aclParamsList);
+                        break;
+                    case REMOVE:
+                        authorizationManager.removeAcls(organizationId, members, aclParamsList);
+                        break;
+                    case RESET:
+                        for (AuthorizationManager.CatalogAclParams aclParam : aclParamsList) {
+                            aclParam.setPermissions(null);
+                        }
+                        authorizationManager.removeAcls(organizationId, members, aclParamsList);
+                        break;
+                    default:
+                        throw new CatalogException("Unexpected error occurred. No valid action found.");
+                }
+
+                OpenCGAResult<AclEntryList<WorkflowPermissions>> queryResults = authorizationManager.getAcls(organizationId, study.getUid(),
+                        workflowUids, members, Enums.Resource.WORKFLOW, WorkflowPermissions.class);
+
+                for (int i = 0; i < queryResults.getResults().size(); i++) {
+                    queryResults.getResults().get(i).setId(workflowIds.get(i));
+                }
+                aclResultList.append(queryResults);
+
+                for (Workflow workflow : batchWorkflowList) {
+                    auditManager.audit(organizationId, operationId, userId, Enums.Action.UPDATE_ACLS, Enums.Resource.WORKFLOW,
+                            workflow.getId(), workflow.getUuid(), study.getId(), study.getUuid(), auditParams,
+                            new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS), new ObjectMap());
+                }
+            } catch (CatalogException e) {
+                // Process current batch
+                for (Workflow workflow : batchWorkflowList) {
+                    auditManager.audit(organizationId, operationId, userId, Enums.Action.UPDATE_ACLS, Enums.Resource.WORKFLOW,
+                            workflow.getId(), workflow.getUuid(), study.getId(), study.getUuid(), auditParams,
+                            new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()), new ObjectMap());
+                }
+
+                // Process remaining unprocessed batches
+                while (numProcessed < workflowList.size()) {
+                    Workflow workflow = workflowList.get(numProcessed);
+                    auditManager.audit(organizationId, operationId, userId, Enums.Action.UPDATE_ACLS, Enums.Resource.WORKFLOW,
+                            workflow.getId(), workflow.getUuid(), study.getId(), study.getUuid(), auditParams,
+                            new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()), new ObjectMap());
+                }
+
+                auditManager.finishAuditBatch(organizationId, operationId);
+                throw e;
+            }
+        } while (numProcessed < workflowList.size());
+
+        auditManager.finishAuditBatch(organizationId, operationId);
+        return aclResultList;
+    }
+
 }
diff --git a/opencga-client/src/main/R/R/AllGenerics.R b/opencga-client/src/main/R/R/AllGenerics.R
index 5b3e3d890ce..43e9f2da447 100644
--- a/opencga-client/src/main/R/R/AllGenerics.R
+++ b/opencga-client/src/main/R/R/AllGenerics.R
@@ -28,6 +28,11 @@ setGeneric("fileClient", function(OpencgaR, annotationSet, file, files, folder,
 setGeneric("jobClient", function(OpencgaR, job, jobs, members, endpointName, params=NULL, ...)
     standardGeneric("jobClient"))
 
+# ##############################################################################
+## WorkflowClient
+setGeneric("workflowClient", function(OpencgaR, workflowId, workflows, endpointName, params=NULL, ...)
+    standardGeneric("workflowClient"))
+
 # ##############################################################################
 ## SampleClient
 setGeneric("sampleClient", function(OpencgaR, annotationSet, members, sample, samples, endpointName, params=NULL, ...)
diff --git a/opencga-client/src/main/R/R/Workflow-methods.R b/opencga-client/src/main/R/R/Workflow-methods.R
new file mode 100644
index 00000000000..acda02de8d1
--- /dev/null
+++ b/opencga-client/src/main/R/R/Workflow-methods.R
@@ -0,0 +1,136 @@
+
+# WARNING: AUTOGENERATED CODE
+#
+#    This code was generated by a tool.
+#    
+#    Manual changes to this file may cause unexpected behavior in your application.
+#    Manual changes to this file will be overwritten if the code is regenerated.
+
+
+# ##############################################################################
+#' WorkflowClient methods
+#' @include AllClasses.R
+#' @include AllGenerics.R
+#' @include commons.R
+
+#' @description This function implements the OpenCGA calls for managing Workflows.
+
+#' The following table summarises the available *actions* for this client:
+#'
+#' | endpointName | Endpoint WS | parameters accepted |
+#' | -- | :-- | --: |
+#' | create | /{apiVersion}/workflows/create | include, exclude, study, includeResult, body[*] |
+#' | distinct | /{apiVersion}/workflows/distinct | study, id, uuid, creationDate, modificationDate, acl, release, snapshot, deleted, field[*] |
+#' | run | /{apiVersion}/workflows/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
+#' | search | /{apiVersion}/workflows/search | include, exclude, limit, skip, count, study, id, uuid, creationDate, modificationDate, acl, release, snapshot, deleted |
+#' | update | /{apiVersion}/workflows/{workflowId}/update | include, exclude, workflowId[*], study, includeResult, body |
+#' | acl | /{apiVersion}/workflows/{workflows}/acl | workflows[*], study, member, silent |
+#' | delete | /{apiVersion}/workflows/{workflows}/delete | study, workflows[*] |
+#' | info | /{apiVersion}/workflows/{workflows}/info | include, exclude, workflows[*], study, version, deleted |
+#'
+#' @md
+#' @seealso \url{http://docs.opencb.org/display/opencga/Using+OpenCGA} and the RESTful API documentation
+#' \url{http://bioinfo.hpc.cam.ac.uk/opencga-prod/webservices/}
+#' [*]: Required parameter
+#' @export
+
+setMethod("workflowClient", "OpencgaR", function(OpencgaR, workflowId, workflows, endpointName, params=NULL, ...) {
+    switch(endpointName,
+
+        #' @section Endpoint /{apiVersion}/workflows/create:
+        #' Create a workflow.
+        #' @param include Fields included in the response, whole JSON path must be provided.
+        #' @param exclude Fields excluded in the response, whole JSON path must be provided.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param includeResult Flag indicating to include the created or updated document result in the response.
+        #' @param data JSON containing workflow information.
+        create=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory=NULL,
+                subcategoryId=NULL, action="create", params=params, httpMethod="POST", as.queryParam=NULL, ...),
+
+        #' @section Endpoint /{apiVersion}/workflows/distinct:
+        #' Workflow distinct method.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param id Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+        #' @param uuid Comma separated list workflow UUIDs up to a maximum of 100.
+        #' @param creationDate Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+        #' @param modificationDate Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+        #' @param acl Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example: acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS permissions. Only study owners or administrators can query by this field. .
+        #' @param release Release when it was created.
+        #' @param snapshot Snapshot value (Latest version of the entry in the specified release).
+        #' @param deleted Boolean to retrieve deleted entries.
+        #' @param field Comma separated list of fields for which to obtain the distinct values.
+        distinct=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory=NULL,
+                subcategoryId=NULL, action="distinct", params=params, httpMethod="GET", as.queryParam=c("field"), ...),
+
+        #' @section Endpoint /{apiVersion}/workflows/run:
+        #' Execute a Nextflow analysis.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param jobId Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+        #' @param jobDescription Job description.
+        #' @param jobDependsOn Comma separated list of existing job IDs the job will depend on.
+        #' @param jobTags Job tags.
+        #' @param jobScheduledStartTime Time when the job is scheduled to start.
+        #' @param jobPriority Priority of the job.
+        #' @param jobDryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+        #' @param data HRDetect analysis parameters.
+        run=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory=NULL, subcategoryId=NULL,
+                action="run", params=params, httpMethod="POST", as.queryParam=NULL, ...),
+
+        #' @section Endpoint /{apiVersion}/workflows/search:
+        #' Workflow search method.
+        #' @param include Fields included in the response, whole JSON path must be provided.
+        #' @param exclude Fields excluded in the response, whole JSON path must be provided.
+        #' @param limit Number of results to be returned.
+        #' @param skip Number of results to skip.
+        #' @param count Get the total number of results matching the query. Deactivated by default.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param id Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+        #' @param uuid Comma separated list workflow UUIDs up to a maximum of 100.
+        #' @param creationDate Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+        #' @param modificationDate Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+        #' @param acl Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example: acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS permissions. Only study owners or administrators can query by this field. .
+        #' @param release Release when it was created.
+        #' @param snapshot Snapshot value (Latest version of the entry in the specified release).
+        #' @param deleted Boolean to retrieve deleted entries.
+        search=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory=NULL,
+                subcategoryId=NULL, action="search", params=params, httpMethod="GET", as.queryParam=NULL, ...),
+
+        #' @section Endpoint /{apiVersion}/workflows/{workflowId}/update:
+        #' Update some workflow attributes.
+        #' @param include Fields included in the response, whole JSON path must be provided.
+        #' @param exclude Fields excluded in the response, whole JSON path must be provided.
+        #' @param workflowId Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param includeResult Flag indicating to include the created or updated document result in the response.
+        #' @param data body.
+        update=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=workflowId, subcategory=NULL,
+                subcategoryId=NULL, action="update", params=params, httpMethod="POST", as.queryParam=NULL, ...),
+
+        #' @section Endpoint /{apiVersion}/workflows/{workflows}/acl:
+        #' Returns the acl of the workflows. If member is provided, it will only return the acl for the member.
+        #' @param workflows Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param member User or group id.
+        #' @param silent Boolean to retrieve all possible entries that are queried for, false to raise an exception whenever one of the entries looked for cannot be shown for whichever reason.
+        acl=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=workflows, subcategory=NULL,
+                subcategoryId=NULL, action="acl", params=params, httpMethod="GET", as.queryParam=NULL, ...),
+
+        #' @section Endpoint /{apiVersion}/workflows/{workflows}/delete:
+        #' Delete workflows.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param workflows Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+        delete=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=workflows, subcategory=NULL,
+                subcategoryId=NULL, action="delete", params=params, httpMethod="DELETE", as.queryParam=NULL, ...),
+
+        #' @section Endpoint /{apiVersion}/workflows/{workflows}/info:
+        #' Get workflow information.
+        #' @param include Fields included in the response, whole JSON path must be provided.
+        #' @param exclude Fields excluded in the response, whole JSON path must be provided.
+        #' @param workflows Comma separated list sample IDs or UUIDs up to a maximum of 100.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param version Comma separated list of workflow versions. 'all' to get all the workflow versions. Not supported if multiple workflow ids are provided.
+        #' @param deleted Boolean to retrieve deleted entries.
+        info=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=workflows, subcategory=NULL,
+                subcategoryId=NULL, action="info", params=params, httpMethod="GET", as.queryParam=NULL, ...),
+    )
+})
\ No newline at end of file
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
new file mode 100644
index 00000000000..58f83fa792f
--- /dev/null
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
@@ -0,0 +1,209 @@
+/*
+* Copyright 2015-2024 OpenCB
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package org.opencb.opencga.client.rest.clients;
+
+import java.lang.Object;
+import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.opencga.client.config.ClientConfiguration;
+import org.opencb.opencga.client.exceptions.ClientException;
+import org.opencb.opencga.client.rest.*;
+import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.variant.HRDetectAnalysisParams;
+import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
+import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
+import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
+import org.opencb.opencga.core.response.RestResponse;
+
+
+/*
+* WARNING: AUTOGENERATED CODE
+*
+* This code was generated by a tool.
+*
+* Manual changes to this file may cause unexpected behavior in your application.
+* Manual changes to this file will be overwritten if the code is regenerated.
+*/
+
+
+/**
+ * This class contains methods for the Workflow webservices.
+ *    PATH: workflows
+ */
+public class WorkflowClient extends AbstractParentClient {
+
+    public WorkflowClient(String token, ClientConfiguration configuration) {
+        super(token, configuration);
+    }
+
+    /**
+     * Create a workflow.
+     * @param data JSON containing workflow information.
+     * @param params Map containing any of the following optional parameters.
+     *       include: Fields included in the response, whole JSON path must be provided.
+     *       exclude: Fields excluded in the response, whole JSON path must be provided.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       includeResult: Flag indicating to include the created or updated document result in the response.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Workflow> create(WorkflowCreateParams data, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.put("body", data);
+        return execute("workflows", null, null, null, "create", params, POST, Workflow.class);
+    }
+
+    /**
+     * Workflow distinct method.
+     * @param field Comma separated list of fields for which to obtain the distinct values.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       id: Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~',
+     *            i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+     *       uuid: Comma separated list workflow UUIDs up to a maximum of 100.
+     *       creationDate: Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+     *       modificationDate: Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+     *       acl: Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example:
+     *            acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS
+     *            permissions. Only study owners or administrators can query by this field. .
+     *       release: Release when it was created.
+     *       snapshot: Snapshot value (Latest version of the entry in the specified release).
+     *       deleted: Boolean to retrieve deleted entries.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Object> distinct(String field, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.putIfNotNull("field", field);
+        return execute("workflows", null, null, null, "distinct", params, GET, Object.class);
+    }
+
+    /**
+     * Execute a Nextflow analysis.
+     * @param data HRDetect analysis parameters.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       jobId: Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+     *       jobDescription: Job description.
+     *       jobDependsOn: Comma separated list of existing job IDs the job will depend on.
+     *       jobTags: Job tags.
+     *       jobScheduledStartTime: Time when the job is scheduled to start.
+     *       jobPriority: Priority of the job.
+     *       jobDryRun: Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all
+     *            parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Job> run(HRDetectAnalysisParams data, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.put("body", data);
+        return execute("workflows", null, null, null, "run", params, POST, Job.class);
+    }
+
+    /**
+     * Workflow search method.
+     * @param params Map containing any of the following optional parameters.
+     *       include: Fields included in the response, whole JSON path must be provided.
+     *       exclude: Fields excluded in the response, whole JSON path must be provided.
+     *       limit: Number of results to be returned.
+     *       skip: Number of results to skip.
+     *       count: Get the total number of results matching the query. Deactivated by default.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       id: Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~',
+     *            i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+     *       uuid: Comma separated list workflow UUIDs up to a maximum of 100.
+     *       creationDate: Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+     *       modificationDate: Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+     *       acl: Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example:
+     *            acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS
+     *            permissions. Only study owners or administrators can query by this field. .
+     *       release: Release when it was created.
+     *       snapshot: Snapshot value (Latest version of the entry in the specified release).
+     *       deleted: Boolean to retrieve deleted entries.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Workflow> search(ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        return execute("workflows", null, null, null, "search", params, GET, Workflow.class);
+    }
+
+    /**
+     * Update some workflow attributes.
+     * @param workflowId Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+     * @param data body.
+     * @param params Map containing any of the following optional parameters.
+     *       include: Fields included in the response, whole JSON path must be provided.
+     *       exclude: Fields excluded in the response, whole JSON path must be provided.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       includeResult: Flag indicating to include the created or updated document result in the response.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Workflow> update(String workflowId, WorkflowUpdateParams data, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.put("body", data);
+        return execute("workflows", workflowId, null, null, "update", params, POST, Workflow.class);
+    }
+
+    /**
+     * Returns the acl of the workflows. If member is provided, it will only return the acl for the member.
+     * @param workflows Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       member: User or group id.
+     *       silent: Boolean to retrieve all possible entries that are queried for, false to raise an exception whenever one of the entries
+     *            looked for cannot be shown for whichever reason.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<WorkflowAclEntryList> acl(String workflows, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        return execute("workflows", workflows, null, null, "acl", params, GET, WorkflowAclEntryList.class);
+    }
+
+    /**
+     * Delete workflows.
+     * @param workflows Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Workflow> delete(String workflows, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        return execute("workflows", workflows, null, null, "delete", params, DELETE, Workflow.class);
+    }
+
+    /**
+     * Get workflow information.
+     * @param workflows Comma separated list sample IDs or UUIDs up to a maximum of 100.
+     * @param params Map containing any of the following optional parameters.
+     *       include: Fields included in the response, whole JSON path must be provided.
+     *       exclude: Fields excluded in the response, whole JSON path must be provided.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       version: Comma separated list of workflow versions. 'all' to get all the workflow versions. Not supported if multiple workflow
+     *            ids are provided.
+     *       deleted: Boolean to retrieve deleted entries.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Workflow> info(String workflows, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        return execute("workflows", workflows, null, null, "info", params, GET, Workflow.class);
+    }
+}
diff --git a/opencga-client/src/main/javascript/Workflow.js b/opencga-client/src/main/javascript/Workflow.js
new file mode 100644
index 00000000000..64c855a09fc
--- /dev/null
+++ b/opencga-client/src/main/javascript/Workflow.js
@@ -0,0 +1,170 @@
+/**
+ * Copyright 2015-2024 OpenCB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * WARNING: AUTOGENERATED CODE
+ * 
+ * This code was generated by a tool.
+ * 
+ * Manual changes to this file may cause unexpected behavior in your application.
+ * Manual changes to this file will be overwritten if the code is regenerated. 
+ *
+**/
+
+import OpenCGAParentClass from "./../opencga-parent-class.js";
+
+
+/**
+ * This class contains the methods for the "Workflow" resource
+ */
+
+export default class Workflow extends OpenCGAParentClass {
+
+    constructor(config) {
+        super(config);
+    }
+
+    /** Create a workflow
+    * @param {Object} data - JSON containing workflow information.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.include] - Fields included in the response, whole JSON path must be provided.
+    * @param {String} [params.exclude] - Fields excluded in the response, whole JSON path must be provided.
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {Boolean} [params.includeResult = "false"] - Flag indicating to include the created or updated document result in the response.
+    *     The default value is false.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    create(data, params) {
+        return this._post("workflows", null, null, null, "create", data, params);
+    }
+
+    /** Workflow distinct method
+    * @param {String} field - Comma separated list of fields for which to obtain the distinct values.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {String} [params.id] - Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using
+    *     the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+    * @param {String} [params.uuid] - Comma separated list workflow UUIDs up to a maximum of 100.
+    * @param {String} [params.creationDate] - Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+    * @param {String} [params.modificationDate] - Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+    * @param {String} [params.acl] - Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}.
+    *     Example: acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS
+    *     permissions. Only study owners or administrators can query by this field. .
+    * @param {String} [params.release] - Release when it was created.
+    * @param {Number} [params.snapshot] - Snapshot value (Latest version of the entry in the specified release).
+    * @param {Boolean} [params.deleted = "false"] - Boolean to retrieve deleted entries. The default value is false.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    distinct(field, params) {
+        return this._get("workflows", null, null, null, "distinct", {field, ...params});
+    }
+
+    /** Execute a Nextflow analysis.
+    * @param {Object} data - HRDetect analysis parameters.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {String} [params.jobId] - Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not
+    *     provided.
+    * @param {String} [params.jobDescription] - Job description.
+    * @param {String} [params.jobDependsOn] - Comma separated list of existing job IDs the job will depend on.
+    * @param {String} [params.jobTags] - Job tags.
+    * @param {String} [params.jobScheduledStartTime] - Time when the job is scheduled to start.
+    * @param {String} [params.jobPriority] - Priority of the job.
+    * @param {Boolean} [params.jobDryRun] - Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will
+    *     validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    run(data, params) {
+        return this._post("workflows", null, null, null, "run", data, params);
+    }
+
+    /** Workflow search method
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.include] - Fields included in the response, whole JSON path must be provided.
+    * @param {String} [params.exclude] - Fields excluded in the response, whole JSON path must be provided.
+    * @param {Number} [params.limit] - Number of results to be returned.
+    * @param {Number} [params.skip] - Number of results to skip.
+    * @param {Boolean} [params.count = "false"] - Get the total number of results matching the query. Deactivated by default. The default
+    *     value is false.
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {String} [params.id] - Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using
+    *     the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+    * @param {String} [params.uuid] - Comma separated list workflow UUIDs up to a maximum of 100.
+    * @param {String} [params.creationDate] - Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+    * @param {String} [params.modificationDate] - Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+    * @param {String} [params.acl] - Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}.
+    *     Example: acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS
+    *     permissions. Only study owners or administrators can query by this field. .
+    * @param {String} [params.release] - Release when it was created.
+    * @param {Number} [params.snapshot] - Snapshot value (Latest version of the entry in the specified release).
+    * @param {Boolean} [params.deleted = "false"] - Boolean to retrieve deleted entries. The default value is false.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    search(params) {
+        return this._get("workflows", null, null, null, "search", params);
+    }
+
+    /** Update some workflow attributes
+    * @param {String} workflowId - Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+    * @param {Object} [data] - body.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.include] - Fields included in the response, whole JSON path must be provided.
+    * @param {String} [params.exclude] - Fields excluded in the response, whole JSON path must be provided.
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {Boolean} [params.includeResult = "false"] - Flag indicating to include the created or updated document result in the response.
+    *     The default value is false.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    update(workflowId, data, params) {
+        return this._post("workflows", workflowId, null, null, "update", data, params);
+    }
+
+    /** Returns the acl of the workflows. If member is provided, it will only return the acl for the member.
+    * @param {String} workflows - Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {String} [params.member] - User or group id.
+    * @param {Boolean} [params.silent = "false"] - Boolean to retrieve all possible entries that are queried for, false to raise an
+    *     exception whenever one of the entries looked for cannot be shown for whichever reason. The default value is false.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    acl(workflows, params) {
+        return this._get("workflows", workflows, null, null, "acl", params);
+    }
+
+    /** Delete workflows
+    * @param {String} workflows - Comma separated list workflow IDs or UUIDs up to a maximum of 100.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    delete(workflows, params) {
+        return this._delete("workflows", workflows, null, null, "delete", params);
+    }
+
+    /** Get workflow information
+    * @param {String} workflows - Comma separated list sample IDs or UUIDs up to a maximum of 100.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.include] - Fields included in the response, whole JSON path must be provided.
+    * @param {String} [params.exclude] - Fields excluded in the response, whole JSON path must be provided.
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {String} [params.version] - Comma separated list of workflow versions. 'all' to get all the workflow versions. Not supported if
+    *     multiple workflow ids are provided.
+    * @param {Boolean} [params.deleted = "false"] - Boolean to retrieve deleted entries. The default value is false.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    info(workflows, params) {
+        return this._get("workflows", workflows, null, null, "info", params);
+    }
+
+}
\ No newline at end of file
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
new file mode 100644
index 00000000000..2ff82ef4192
--- /dev/null
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
@@ -0,0 +1,207 @@
+"""
+WARNING: AUTOGENERATED CODE
+
+    This code was generated by a tool.
+    
+    Manual changes to this file may cause unexpected behavior in your application.
+    Manual changes to this file will be overwritten if the code is regenerated.
+"""
+
+from pyopencga.rest_clients._parent_rest_clients import _ParentRestClient
+
+
+class Workflow(_ParentRestClient):
+    """
+    This class contains methods for the 'Workflows' webservices
+    PATH: /{apiVersion}/workflows
+    """
+
+    def __init__(self, configuration, token=None, login_handler=None, *args, **kwargs):
+        super(Workflow, self).__init__(configuration, token, login_handler, *args, **kwargs)
+
+    def create(self, data=None, **options):
+        """
+        Create a workflow.
+        PATH: /{apiVersion}/workflows/create
+
+        :param dict data: JSON containing workflow information. (REQUIRED)
+        :param str include: Fields included in the response, whole JSON path
+            must be provided.
+        :param str exclude: Fields excluded in the response, whole JSON path
+            must be provided.
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param bool include_result: Flag indicating to include the created or
+            updated document result in the response.
+        """
+
+        return self._post(category='workflows', resource='create', data=data, **options)
+
+    def distinct(self, field, **options):
+        """
+        Workflow distinct method.
+        PATH: /{apiVersion}/workflows/distinct
+
+        :param str field: Comma separated list of fields for which to obtain
+            the distinct values. (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str id: Comma separated list workflow IDs up to a maximum of
+            100. Also admits basic regular expressions using the operator '~',
+            i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i'
+            for case insensitive search.
+        :param str uuid: Comma separated list workflow UUIDs up to a maximum
+            of 100.
+        :param str creation_date: Creation date. Format: yyyyMMddHHmmss.
+            Examples: >2018, 2017-2018, <201805.
+        :param str modification_date: Modification date. Format:
+            yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+        :param str acl: Filter entries for which a user has the provided
+            permissions. Format: acl={user}:{permissions}. Example:
+            acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which
+            user john has both WRITE and WRITE_ANNOTATIONS permissions. Only
+            study owners or administrators can query by this field. .
+        :param str release: Release when it was created.
+        :param int snapshot: Snapshot value (Latest version of the entry in
+            the specified release).
+        :param bool deleted: Boolean to retrieve deleted entries.
+        """
+
+        options['field'] = field
+        return self._get(category='workflows', resource='distinct', **options)
+
+    def run(self, data=None, **options):
+        """
+        Execute a Nextflow analysis.
+        PATH: /{apiVersion}/workflows/run
+
+        :param dict data: HRDetect analysis parameters. (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str job_id: Job ID. It must be a unique string within the
+            study. An ID will be autogenerated automatically if not provided.
+        :param str job_description: Job description.
+        :param str job_depends_on: Comma separated list of existing job IDs
+            the job will depend on.
+        :param str job_tags: Job tags.
+        :param str job_scheduled_start_time: Time when the job is scheduled to
+            start.
+        :param str job_priority: Priority of the job.
+        :param bool job_dry_run: Flag indicating that the job will be executed
+            in dry-run mode. In this mode, OpenCGA will validate that all
+            parameters and prerequisites are correctly set for successful
+            execution, but the job will not actually run.
+        """
+
+        return self._post(category='workflows', resource='run', data=data, **options)
+
+    def search(self, **options):
+        """
+        Workflow search method.
+        PATH: /{apiVersion}/workflows/search
+
+        :param str include: Fields included in the response, whole JSON path
+            must be provided.
+        :param str exclude: Fields excluded in the response, whole JSON path
+            must be provided.
+        :param int limit: Number of results to be returned.
+        :param int skip: Number of results to skip.
+        :param bool count: Get the total number of results matching the query.
+            Deactivated by default.
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str id: Comma separated list workflow IDs up to a maximum of
+            100. Also admits basic regular expressions using the operator '~',
+            i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i'
+            for case insensitive search.
+        :param str uuid: Comma separated list workflow UUIDs up to a maximum
+            of 100.
+        :param str creation_date: Creation date. Format: yyyyMMddHHmmss.
+            Examples: >2018, 2017-2018, <201805.
+        :param str modification_date: Modification date. Format:
+            yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
+        :param str acl: Filter entries for which a user has the provided
+            permissions. Format: acl={user}:{permissions}. Example:
+            acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which
+            user john has both WRITE and WRITE_ANNOTATIONS permissions. Only
+            study owners or administrators can query by this field. .
+        :param str release: Release when it was created.
+        :param int snapshot: Snapshot value (Latest version of the entry in
+            the specified release).
+        :param bool deleted: Boolean to retrieve deleted entries.
+        """
+
+        return self._get(category='workflows', resource='search', **options)
+
+    def update(self, workflow_id, data=None, **options):
+        """
+        Update some workflow attributes.
+        PATH: /{apiVersion}/workflows/{workflowId}/update
+
+        :param str workflow_id: Comma separated list workflow IDs or UUIDs up
+            to a maximum of 100. (REQUIRED)
+        :param str include: Fields included in the response, whole JSON path
+            must be provided.
+        :param str exclude: Fields excluded in the response, whole JSON path
+            must be provided.
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param bool include_result: Flag indicating to include the created or
+            updated document result in the response.
+        :param dict data: body.
+        """
+
+        return self._post(category='workflows', resource='update', query_id=workflow_id, data=data, **options)
+
+    def acl(self, workflows, **options):
+        """
+        Returns the acl of the workflows. If member is provided, it will only
+            return the acl for the member.
+        PATH: /{apiVersion}/workflows/{workflows}/acl
+
+        :param str workflows: Comma separated list workflow IDs or UUIDs up to
+            a maximum of 100. (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str member: User or group id.
+        :param bool silent: Boolean to retrieve all possible entries that are
+            queried for, false to raise an exception whenever one of the
+            entries looked for cannot be shown for whichever reason.
+        """
+
+        return self._get(category='workflows', resource='acl', query_id=workflows, **options)
+
+    def delete(self, workflows, **options):
+        """
+        Delete workflows.
+        PATH: /{apiVersion}/workflows/{workflows}/delete
+
+        :param str workflows: Comma separated list workflow IDs or UUIDs up to
+            a maximum of 100. (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        """
+
+        return self._delete(category='workflows', resource='delete', query_id=workflows, **options)
+
+    def info(self, workflows, **options):
+        """
+        Get workflow information.
+        PATH: /{apiVersion}/workflows/{workflows}/info
+
+        :param str workflows: Comma separated list sample IDs or UUIDs up to a
+            maximum of 100. (REQUIRED)
+        :param str include: Fields included in the response, whole JSON path
+            must be provided.
+        :param str exclude: Fields excluded in the response, whole JSON path
+            must be provided.
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str version: Comma separated list of workflow versions. 'all'
+            to get all the workflow versions. Not supported if multiple
+            workflow ids are provided.
+        :param bool deleted: Boolean to retrieve deleted entries.
+        """
+
+        return self._get(category='workflows', resource='info', query_id=workflows, **options)
+
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
index 0c5c0d27c4b..7040b87198f 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
@@ -578,6 +578,20 @@ public class ParamConstants {
             + " OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will"
             + " not actually run.";
 
+    // ---------------------------------------------
+    // WORKFLOWS
+    public static final String WORKFLOW_VERSION_PARAM = "version";
+    public static final String WORKFLOW_VERSION_DESCRIPTION = "Comma separated list of workflow versions. 'all' to get all the workflow "
+            + "versions. Not supported if multiple workflow ids are provided";
+    public static final String WORKFLOWS_ID_PARAM = "id";
+    public static final String WORKFLOWS_ID_DESCRIPTION = "Comma separated list workflow IDs" + UP_TO_100 + REGEX_SUPPORT;
+    public static final String WORKFLOWS_UUID_DESCRIPTION = "Comma separated list workflow UUIDs" + UP_TO_100;
+    public static final String WORKFLOWS_UUID_PARAM = "uuid";
+    public static final String WORKFLOWS_TYPE_DESCRIPTION = "Workflow type. Allowed types: [NEXTFLOW]";
+    public static final String WORKFLOWS_TYPE_PARAM = "type";
+    public static final String WORKFLOW_SCRIPTS_ACTION_DESCRIPTION = "Action to be performed if the array of scripts is being updated "
+            + "[SET, ADD, REMOVE]";
+    public static final String WORKFLOW_SCRIPTS_ACTION_PARAM = "scriptsAction";
     // ---------------------------------------------
     public static final String JOB_INPUT_FILES_PARAM = "input";
     public static final String JOB_INPUT_FILES_DESCRIPTION = "Comma separated list of file IDs used as input.";
@@ -1526,6 +1540,8 @@ public class ParamConstants {
     public static final String JOBS_DESCRIPTION = "Comma separated list of job IDs or UUIDs" + UP_TO_100;
     public static final String JOB_IDS_DESCRIPTION = "Comma separated list of job IDs" + UP_TO_100 + REGEX_SUPPORT;
     public static final String JOB_UUIDS_DESCRIPTION = "Comma separated list of job UUIDs" + UP_TO_100;
+    public static final String WORKFLOWS_DESCRIPTION = "Comma separated list workflow IDs or UUIDs" + UP_TO_100;
+    public static final String WORKFLOW_DESCRIPTION = "Workflow ID or UUID";
     // ---------------------------------------------
     public static final String PROJECTS_DESCRIPTION = "Comma separated list of projects [organization@]project" + UP_TO_100;
     // ---------------------------------------------
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/generator/ClientsGeneratorMain.java b/opencga-server/src/main/java/org/opencb/opencga/server/generator/ClientsGeneratorMain.java
index 33014c26b4e..cf410f97a33 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/generator/ClientsGeneratorMain.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/generator/ClientsGeneratorMain.java
@@ -40,6 +40,7 @@ public static void main(String[] args) throws URISyntaxException {
         classes.add(StudyWSServer.class);
         classes.add(FileWSServer.class);
         classes.add(JobWSServer.class);
+        classes.add(WorkflowWSServer.class);
         classes.add(SampleWSServer.class);
         classes.add(IndividualWSServer.class);
         classes.add(FamilyWSServer.class);
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/MetaWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/MetaWSServer.java
index 6569dd3effe..2429ec7361c 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/MetaWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/MetaWSServer.java
@@ -127,6 +127,7 @@ public Response api(@ApiParam(value = "List of categories to get API from") @Que
         classMap.put("studies", StudyWSServer.class);
         classMap.put("files", FileWSServer.class);
         classMap.put("jobs", JobWSServer.class);
+        classMap.put("workflows", WorkflowWSServer.class);
         classMap.put("samples", SampleWSServer.class);
         classMap.put("individuals", IndividualWSServer.class);
         classMap.put("families", FamilyWSServer.class);
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
new file mode 100644
index 00000000000..94c4e849fab
--- /dev/null
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
@@ -0,0 +1,243 @@
+package org.opencb.opencga.server.rest;
+
+import org.apache.commons.lang3.ObjectUtils;
+import org.opencb.commons.datastore.core.DataResult;
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.opencga.analysis.variant.hrdetect.HRDetectAnalysis;
+import org.opencb.opencga.analysis.workflow.NextFlowExecutor;
+import org.opencb.opencga.catalog.managers.WorkflowManager;
+import org.opencb.opencga.catalog.utils.Constants;
+import org.opencb.opencga.core.api.ParamConstants;
+import org.opencb.opencga.core.exceptions.VersionException;
+import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.variant.HRDetectAnalysisParams;
+import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
+import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
+import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
+import org.opencb.opencga.core.tools.annotations.*;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.ws.rs.*;
+import javax.ws.rs.core.*;
+import java.io.IOException;
+import java.util.List;
+
+import static org.opencb.opencga.core.api.ParamConstants.JOB_DEPENDS_ON;
+
+@Path("/{apiVersion}/workflows")
+@Produces(MediaType.APPLICATION_JSON)
+@Api(value = "Workflows", description = "Methods for working with 'workflows' endpoint")
+public class WorkflowWSServer extends OpenCGAWSServer {
+
+    private WorkflowManager workflowManager;
+
+    public WorkflowWSServer(@Context UriInfo uriInfo, @Context HttpServletRequest httpServletRequest, @Context HttpHeaders httpHeaders)
+            throws IOException, VersionException {
+        super(uriInfo, httpServletRequest, httpHeaders);
+        workflowManager = catalogManager.getWorkflowManager();
+    }
+
+    @GET
+    @Path("/{workflows}/info")
+    @ApiOperation(value = "Get workflow information", response = Workflow.class)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = QueryOptions.INCLUDE, value = ParamConstants.INCLUDE_DESCRIPTION, format = "", example = "name,attributes",
+                    dataType = "string", paramType = "query"),
+            @ApiImplicitParam(name = QueryOptions.EXCLUDE, value = ParamConstants.EXCLUDE_DESCRIPTION, example = "id,status", dataType =
+                    "string", paramType = "query")
+    })
+    public Response workflowInfo(
+            @ApiParam(value = ParamConstants.SAMPLES_DESCRIPTION, required = true) @PathParam("workflows") String workflowStr,
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+            @ApiParam(value = ParamConstants.WORKFLOW_VERSION_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOW_VERSION_PARAM) String version,
+            @ApiParam(value = ParamConstants.DELETED_DESCRIPTION, defaultValue = "false") @QueryParam(ParamConstants.DELETED_PARAM) boolean deleted) {
+        try {
+            query.remove(ParamConstants.STUDY_PARAM);
+
+            List<String> workflowList = getIdList(workflowStr);
+            DataResult<Workflow> workflowDataResult = workflowManager.get(studyStr, workflowList, query, queryOptions, true, token);
+            return createOkResponse(workflowDataResult);
+        } catch (Exception e) {
+            return createErrorResponse(e);
+        }
+    }
+
+    @POST
+    @Path("/create")
+    @ApiOperation(value = "Create a workflow", response = Workflow.class, notes = "Create a workflow.")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = QueryOptions.INCLUDE, value = ParamConstants.INCLUDE_DESCRIPTION,
+                    dataType = "string", paramType = "query"),
+            @ApiImplicitParam(name = QueryOptions.EXCLUDE, value = ParamConstants.EXCLUDE_DESCRIPTION,
+                    dataType = "string", paramType = "query")
+    })
+    public Response createWorkflowPOST(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+            @ApiParam(value = ParamConstants.INCLUDE_RESULT_DESCRIPTION, defaultValue = "false") @QueryParam(ParamConstants.INCLUDE_RESULT_PARAM) boolean includeResult,
+            @ApiParam(value = "JSON containing workflow information", required = true) WorkflowCreateParams params) {
+        try {
+            params = ObjectUtils.defaultIfNull(params, new WorkflowCreateParams());
+
+            Workflow workflow = params.toWorkflow();
+
+            return createOkResponse(workflowManager.create(studyStr, workflow, queryOptions, token));
+        } catch (Exception e) {
+            return createErrorResponse(e);
+        }
+    }
+
+    @POST
+    @Path("/run")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @ApiOperation(value = NextFlowExecutor.DESCRIPTION, response = Job.class)
+    public Response updateByPost(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String study,
+            @ApiParam(value = ParamConstants.JOB_ID_CREATION_DESCRIPTION) @QueryParam(ParamConstants.JOB_ID) String jobName,
+            @ApiParam(value = ParamConstants.JOB_DESCRIPTION_DESCRIPTION) @QueryParam(ParamConstants.JOB_DESCRIPTION) String jobDescription,
+            @ApiParam(value = ParamConstants.JOB_DEPENDS_ON_DESCRIPTION) @QueryParam(JOB_DEPENDS_ON) String dependsOn,
+            @ApiParam(value = ParamConstants.JOB_TAGS_DESCRIPTION) @QueryParam(ParamConstants.JOB_TAGS) String jobTags,
+            @ApiParam(value = ParamConstants.JOB_SCHEDULED_START_TIME_DESCRIPTION) @QueryParam(ParamConstants.JOB_SCHEDULED_START_TIME) String scheduledStartTime,
+            @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
+            @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
+            @ApiParam(value = HRDetectAnalysisParams.DESCRIPTION, required = true) HRDetectAnalysisParams params) {
+        return submitJob(HRDetectAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+    }
+
+    @GET
+    @Path("/search")
+    @ApiOperation(value = "Workflow search method", response = Workflow.class)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = QueryOptions.INCLUDE, value = ParamConstants.INCLUDE_DESCRIPTION, example = "name,attributes",
+                    dataType = "string", paramType = "query"),
+            @ApiImplicitParam(name = QueryOptions.EXCLUDE, value = ParamConstants.EXCLUDE_DESCRIPTION, example = "id,status", dataType =
+                    "string", paramType = "query"),
+            @ApiImplicitParam(name = QueryOptions.LIMIT, value = ParamConstants.LIMIT_DESCRIPTION, dataType = "integer", paramType =
+                    "query"),
+            @ApiImplicitParam(name = QueryOptions.SKIP, value = ParamConstants.SKIP_DESCRIPTION, dataType = "integer", paramType = "query"),
+            @ApiImplicitParam(name = QueryOptions.COUNT, value = ParamConstants.COUNT_DESCRIPTION, defaultValue = "false", dataType =
+                    "boolean", paramType = "query")
+    })
+    public Response search(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+            @ApiParam(value = ParamConstants.WORKFLOWS_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_ID_PARAM) String id,
+            @ApiParam(value = ParamConstants.WORKFLOWS_UUID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_UUID_PARAM) String uuid,
+//            @ApiParam(value = ParamConstants.WORKFLOWS_TYPE_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TYPE_PARAM) String type,
+            @ApiParam(value = ParamConstants.CREATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.CREATION_DATE_PARAM) String creationDate,
+            @ApiParam(value = ParamConstants.MODIFICATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.MODIFICATION_DATE_PARAM) String modificationDate,
+            @ApiParam(value = ParamConstants.ACL_DESCRIPTION) @QueryParam(ParamConstants.ACL_PARAM) String acl,
+            @ApiParam(value = ParamConstants.RELEASE_DESCRIPTION) @QueryParam(ParamConstants.RELEASE_PARAM) String release,
+            @ApiParam(value = ParamConstants.SNAPSHOT_DESCRIPTION) @QueryParam(ParamConstants.SNAPSHOT_PARAM) int snapshot,
+            @ApiParam(value = ParamConstants.DELETED_DESCRIPTION, defaultValue = "false") @QueryParam(ParamConstants.DELETED_PARAM) boolean deleted
+    ) {
+        try {
+            query.remove(ParamConstants.STUDY_PARAM);
+            return createOkResponse(workflowManager.search(studyStr, query, queryOptions, token));
+        } catch (Exception e) {
+            return createErrorResponse(e);
+        }
+    }
+
+    @GET
+    @Path("/distinct")
+    @ApiOperation(value = "Workflow distinct method", response = Object.class)
+    public Response distinct(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+            @ApiParam(value = ParamConstants.WORKFLOWS_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_ID_PARAM) String id,
+            @ApiParam(value = ParamConstants.WORKFLOWS_UUID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_UUID_PARAM) String uuid,
+//            @ApiParam(value = ParamConstants.WORKFLOWS_TYPE_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TYPE_PARAM) String type,
+            @ApiParam(value = ParamConstants.CREATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.CREATION_DATE_PARAM) String creationDate,
+            @ApiParam(value = ParamConstants.MODIFICATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.MODIFICATION_DATE_PARAM) String modificationDate,
+            @ApiParam(value = ParamConstants.ACL_DESCRIPTION) @QueryParam(ParamConstants.ACL_PARAM) String acl,
+            @ApiParam(value = ParamConstants.RELEASE_DESCRIPTION) @QueryParam(ParamConstants.RELEASE_PARAM) String release,
+            @ApiParam(value = ParamConstants.SNAPSHOT_DESCRIPTION) @QueryParam(ParamConstants.SNAPSHOT_PARAM) int snapshot,
+            @ApiParam(value = ParamConstants.DELETED_DESCRIPTION, defaultValue = "false") @QueryParam(ParamConstants.DELETED_PARAM) boolean deleted,
+            @ApiParam(value = ParamConstants.DISTINCT_FIELD_DESCRIPTION, required = true) @QueryParam(ParamConstants.DISTINCT_FIELD_PARAM) String field) {
+        try {
+            query.remove(ParamConstants.STUDY_PARAM);
+            query.remove(ParamConstants.DISTINCT_FIELD_PARAM);
+            List<String> fields = split(field, ParamConstants.DISTINCT_FIELD_PARAM, true);
+            return createOkResponse(workflowManager.distinct(studyStr, fields, query, token));
+        } catch (Exception e) {
+            return createErrorResponse(e);
+        }
+    }
+
+    @POST
+    @Path("/{workflowId}/update")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @ApiOperation(value = "Update some workflow attributes", response = Workflow.class)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = QueryOptions.INCLUDE, value = ParamConstants.INCLUDE_DESCRIPTION,
+                    dataType = "string", paramType = "query"),
+            @ApiImplicitParam(name = QueryOptions.EXCLUDE, value = ParamConstants.EXCLUDE_DESCRIPTION,
+                    dataType = "string", paramType = "query")
+    })
+    public Response updateByPost(
+            @ApiParam(value = ParamConstants.WORKFLOWS_DESCRIPTION, required = true) @PathParam("workflowId") String workflowId,
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+//            @ApiParam(value = ParamConstants.WORKFLOW_SCRIPTS_ACTION_DESCRIPTION, allowableValues = "ADD,SET,REMOVE", defaultValue = "ADD") @QueryParam(ParamConstants.WORKFLOW_SCRIPTS_ACTION_PARAM) ParamUtils.BasicUpdateAction workflowScriptsAction,
+            @ApiParam(value = ParamConstants.INCLUDE_RESULT_DESCRIPTION, defaultValue = "false") @QueryParam(ParamConstants.INCLUDE_RESULT_PARAM) boolean includeResult,
+            @ApiParam(value = "body") WorkflowUpdateParams parameters) {
+        try {
+//            Map<String, Object> actionMap = new HashMap<>();
+//            queryOptions.put(Constants.ACTIONS, actionMap);
+
+            return createOkResponse(workflowManager.update(studyStr, workflowId, parameters, queryOptions, token), "Workflow update success");
+        } catch (Exception e) {
+            return createErrorResponse(e);
+        }
+    }
+
+    @DELETE
+    @Path("/{workflows}/delete")
+    @ApiOperation(value = "Delete workflows", response = Workflow.class)
+    public Response delete(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+            @ApiParam(value = ParamConstants.WORKFLOWS_DESCRIPTION) @PathParam("workflows") String workflows) {
+        try {
+            return createOkResponse(workflowManager.delete(studyStr, getIdList(workflows), queryOptions, token));
+        } catch (Exception e) {
+            return createErrorResponse(e);
+        }
+    }
+
+    @GET
+    @Path("/{workflows}/acl")
+    @ApiOperation(value = "Returns the acl of the workflows. If member is provided, it will only return the acl for the member.",
+            response = WorkflowAclEntryList.class)
+    public Response getAcls(@ApiParam(value = ParamConstants.WORKFLOWS_DESCRIPTION, required = true) @PathParam("workflows") String workflowIdsStr,
+                            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+                            @ApiParam(value = "User or group id") @QueryParam("member") String member,
+                            @ApiParam(value = ParamConstants.SILENT_DESCRIPTION, defaultValue = "false") @QueryParam(Constants.SILENT) boolean silent) {
+        try {
+            List<String> idList = getIdList(workflowIdsStr);
+            return createOkResponse(workflowManager.getAcls(studyStr, idList, member, silent, token));
+        } catch (Exception e) {
+            return createErrorResponse(e);
+        }
+    }
+
+//    @POST
+//    @Path("/acl/{members}/update")
+//    @ApiOperation(value = "Update the set of permissions granted for the member", response = WorkflowAclEntryList.class)
+//    public Response updateAcl(
+//            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+//            @ApiParam(value = "Comma separated list of user or group ids", required = true) @PathParam("members") String memberId,
+//            @ApiParam(value = ParamConstants.ACL_ACTION_DESCRIPTION, required = true, defaultValue = "ADD") @QueryParam(ParamConstants.ACL_ACTION_PARAM) ParamUtils.AclAction action,
+//            @ApiParam(value = "JSON containing the parameters to update the permissions. If propagate flag is set to true, it will "
+//                    + "propagate the permissions defined to the individuals that are associated to the matching workflows", required = true)
+//            SampleAclUpdateParams params) {
+//        try {
+//            params = ObjectUtils.defaultIfNull(params, new SampleAclUpdateParams());
+//            SampleAclParams sampleAclParams = new SampleAclParams(
+//                    params.getIndividual(), params.getFamily(), params.getFile(), params.getCohort(), params.getPermissions());
+//            List<String> idList = StringUtils.isEmpty(params.getSample()) ? Collections.emptyList() : getIdList(params.getSample(), false);
+//            return createOkResponse(sampleManager.updateAcl(studyStr, idList, memberId, sampleAclParams, action, token));
+//        } catch (Exception e) {
+//            return createErrorResponse(e);
+//        }
+//    }
+
+
+}
diff --git a/opencga-server/src/test/java/org/opencb/opencga/server/generator/RestApiParserTest.java b/opencga-server/src/test/java/org/opencb/opencga/server/generator/RestApiParserTest.java
index e562973199e..a6bbf4dccc5 100644
--- a/opencga-server/src/test/java/org/opencb/opencga/server/generator/RestApiParserTest.java
+++ b/opencga-server/src/test/java/org/opencb/opencga/server/generator/RestApiParserTest.java
@@ -71,6 +71,7 @@ public void parseToFile() throws IOException {
         classes.add(StudyWSServer.class);
         classes.add(FileWSServer.class);
         classes.add(JobWSServer.class);
+        classes.add(WorkflowWSServer.class);
         classes.add(SampleWSServer.class);
         classes.add(IndividualWSServer.class);
         classes.add(FamilyWSServer.class);

From 42edc20116d4ae7d7766d1ce1a5969af87ac523c Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 3 Sep 2024 13:17:02 +0200
Subject: [PATCH 08/99] catalog: support files in workflows, #TASK-6445

---
 .../analysis/utils/InputFileUtils.java        |  46 +++
 .../analysis/workflow/NextFlowExecutor.java   |  44 ++-
 .../analysis/tools/WorkflowExecutorTest.java  |  32 +-
 .../catalog/db/api/WorkflowDBAdaptor.java     |   2 +
 .../db/mongodb/WorkflowMongoDBAdaptor.java    |   5 +-
 .../catalog/managers/StudyManager.java        |   4 +
 .../catalog/managers/WorkflowManager.java     | 283 +++++++++++++++++-
 .../src/main/R/R/Workflow-methods.R           |   2 +-
 .../client/rest/clients/WorkflowClient.java   |   6 +-
 .../src/main/javascript/Workflow.js           |   2 +-
 .../pyopencga/rest_clients/workflow_client.py |   2 +-
 .../opencga/core/api/FieldConstants.java      |   6 +-
 .../models/workflow/NextFlowRunParams.java    |  16 +-
 .../core/models/workflow/Workflow.java        |  53 +++-
 .../models/workflow/WorkflowCreateParams.java |  53 +++-
 .../models/workflow/WorkflowUpdateParams.java |  49 ++-
 .../opencga/server/rest/WorkflowWSServer.java |  11 +-
 17 files changed, 544 insertions(+), 72 deletions(-)
 create mode 100644 opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java
new file mode 100644
index 00000000000..9cdbf4b9efc
--- /dev/null
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java
@@ -0,0 +1,46 @@
+package org.opencb.opencga.analysis.utils;
+
+import org.opencb.opencga.catalog.exceptions.CatalogException;
+import org.opencb.opencga.catalog.managers.CatalogManager;
+import org.opencb.opencga.catalog.managers.FileManager;
+import org.opencb.opencga.core.models.file.File;
+import org.opencb.opencga.core.response.OpenCGAResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class InputFileUtils {
+
+    private final CatalogManager catalogManager;
+
+    private static final Pattern OPERATION_PATTERN = Pattern.compile("^(?i)(ocga://|opencga://)(.+)$");
+
+    private final static Logger logger = LoggerFactory.getLogger(InputFileUtils.class);
+
+    public InputFileUtils(CatalogManager catalogManager) {
+        this.catalogManager = catalogManager;
+    }
+
+    public boolean isValidOpenCGAFile(String file) {
+        return OPERATION_PATTERN.matcher(file).matches();
+    }
+
+    public File getOpenCGAFile(String study, String file, String token) throws CatalogException {
+        Matcher matcher = OPERATION_PATTERN.matcher(file);
+
+        if (!matcher.find()) {
+            throw new CatalogException("Invalid OpenCGA file format. Accepted format is 'ocga://<path>' or 'opencga://<path>'");
+        }
+
+        String filePath = matcher.group(2);
+        logger.info("Looking for file '{}'", filePath);
+        OpenCGAResult<File> result = catalogManager.getFileManager().get(study, filePath, FileManager.INCLUDE_FILE_URI_PATH, token);
+        if (result.getNumResults() == 0) {
+            throw new CatalogException("File '" + file + "' not found in study '" + study + "'");
+        }
+        return result.first();
+    }
+
+}
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 1fcf6acdf0c..029511581a3 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -3,15 +3,18 @@
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
+import org.opencb.opencga.analysis.utils.InputFileUtils;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.models.workflow.WorkflowScript;
@@ -32,10 +35,7 @@
 import java.nio.file.Path;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.LinkedList;
-import java.util.List;
+import java.util.*;
 import java.util.stream.Stream;
 
 @Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.WORKFLOW, description = NextFlowExecutor.DESCRIPTION)
@@ -48,6 +48,9 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
     protected NextFlowRunParams nextflowParams = new NextFlowRunParams();
 
     private Workflow workflow;
+    private String cliParams;
+    // Build list of inputfiles in case we need to specifically mount them in read only mode
+    private List<String> inputFileUris;
 
     private Thread thread;
     private final int monitorThreadPeriod = 5000;
@@ -71,6 +74,31 @@ protected void check() throws Exception {
         if (workflow == null) {
             throw new ToolException("Workflow '" + nextflowParams.getId() + "' is null");
         }
+
+        if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
+            this.inputFileUris = new LinkedList<>();
+            InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
+
+            StringBuilder cliParamsBuilder = new StringBuilder();
+            for (Map.Entry<String, String> entry : nextflowParams.getParams().entrySet()) {
+                if (entry.getKey().startsWith("--")) {
+                    cliParamsBuilder.append(entry.getKey()).append(" ");
+                } else {
+                    cliParamsBuilder.append("--").append(entry.getKey()).append(" ");
+                }
+                if (inputFileUtils.isValidOpenCGAFile(entry.getValue())) {
+                    File file = inputFileUtils.getOpenCGAFile(study, entry.getValue(), token);
+                    cliParamsBuilder.append(file.getUri().getPath()).append(" ");
+                    inputFileUris.add(file.getUri().getPath());
+                } else {
+                    cliParamsBuilder.append(entry.getValue()).append(" ");
+                }
+            }
+            this.cliParams = cliParamsBuilder.toString();
+        } else {
+            this.cliParams = "";
+            this.inputFileUris = Collections.emptyList();
+        }
     }
 
     @Override
@@ -94,8 +122,8 @@ protected void run() throws Exception {
         StringBuilder stringBuilder = new StringBuilder()
                 .append("nextflow -c ").append(workingDirectory).append("/nextflow.config")
                 .append(" run ");
-        if (workflow.getDocker() != null && StringUtils.isNotEmpty(workflow.getDocker().getImage())) {
-            stringBuilder.append(workflow.getDocker().getImage()).append(" -with-docker");
+        if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
+            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {
@@ -104,7 +132,9 @@ protected void run() throws Exception {
                 }
             }
         }
-
+        if (StringUtils.isNotEmpty(cliParams)) {
+            stringBuilder.append(" ").append(cliParams);
+        }
         stringBuilder.append(" -with-report ").append(workingDirectory).append("/report.html");
         List<String> cliArgs = Arrays.asList(StringUtils.split(stringBuilder.toString(), " "));
 
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index 768ce6e4981..5ea6173f8a7 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -23,6 +23,8 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
 public class WorkflowExecutorTest extends AbstractManagerTest {
@@ -39,7 +41,31 @@ public void nextflowScriptTest() throws ToolException, CatalogException, IOExcep
 
         StopWatch stopWatch = StopWatch.createStarted();
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
-        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1);
+        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1, Collections.emptyMap());
+        ObjectMap params = runParams.toObjectMap();
+        params.put(ParamConstants.STUDY_PARAM, studyFqn);
+        nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), catalogManager,
+                StorageEngineFactory.get(storageConfiguration), params, outDir, "", false, ownerToken);
+//        nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), runParams.toObjectMap(), outDir, ownerToken);
+        nextFlowExecutorTest.start();
+        System.out.println(stopWatch.getTime(TimeUnit.MILLISECONDS));
+    }
+
+    @Test
+    public void nextflowScriptWithFilesTest() throws ToolException, CatalogException, IOException {
+        InputStream inputStream = StorageManager.class.getClassLoader().getResourceAsStream("storage-configuration.yml");
+        StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
+
+        WorkflowCreateParams workflow = createDummyWorkflow();
+        catalogManager.getWorkflowManager().create(studyFqn, workflow.toWorkflow(), QueryOptions.empty(), ownerToken);
+
+        Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
+
+        StopWatch stopWatch = StopWatch.createStarted();
+        NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
+        Map<String, String> workflowParams = new HashMap<>();
+        workflowParams.put("file", "ocga://myfile.txt");
+        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1, workflowParams);
         ObjectMap params = runParams.toObjectMap();
         params.put(ParamConstants.STUDY_PARAM, studyFqn);
         nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), catalogManager,
@@ -56,14 +82,14 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         WorkflowCreateParams workflow = new WorkflowCreateParams()
                 .setId("workflow")
 //                .setCommandLine("run nextflow-io/rnaseq-nf -with-docker");
-                .setDocker(new WorkflowRepository("nextflow-io/rnaseq-nf"));
+                .setRepository(new WorkflowRepository("nextflow-io/rnaseq-nf"));
         catalogManager.getWorkflowManager().create(studyFqn, workflow.toWorkflow(), QueryOptions.empty(), ownerToken);
 
         Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
 
         StopWatch stopWatch = StopWatch.createStarted();
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
-        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1);
+        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1, Collections.emptyMap());
         ObjectMap params = runParams.toObjectMap();
         params.put(ParamConstants.STUDY_PARAM, studyFqn);
         nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), catalogManager,
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
index d9761163f77..a50d88c409e 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
@@ -23,9 +23,11 @@ enum QueryParams implements QueryParam {
         UID("uid", LONG, ""),
         UUID("uuid", TEXT, ""),
         DESCRIPTION("description", TEXT, ""),
+        DRAFT("draft", BOOLEAN, ""),
         TYPE("type", TEXT, ""),
         COMMAND_LINE("commandLine", TEXT, ""),
         SCRIPTS("scripts", OBJECT, ""),
+        VARIABLES("variables", OBJECT, ""),
         RELEASE("release", INTEGER, ""), //  Release where the sample was created
         SNAPSHOT("snapshot", INTEGER, ""), // Last version of sample at release = snapshot
         VERSION("version", INTEGER, ""), // Version of the sample
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index 3da0bb5232d..00304341049 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -320,13 +320,16 @@ private UpdateDocument parseAndValidateUpdateParams(ObjectMap parameters, QueryO
             document.getSet().put(PRIVATE_MODIFICATION_DATE, date);
         }
 
+        final String[] acceptedBooleanParams = {QueryParams.DRAFT.key()};
+        filterBooleanParams(parameters, document.getSet(), acceptedBooleanParams);
+
         final String[] acceptedParams = {QueryParams.DESCRIPTION.key(), QueryParams.COMMAND_LINE.key()};
         filterStringParams(parameters, document.getSet(), acceptedParams);
 
         final String[] acceptedMapParams = {QueryParams.ATTRIBUTES.key()};
         filterMapParams(parameters, document.getSet(), acceptedMapParams);
 
-        final String[] acceptedListParams = {QueryParams.SCRIPTS.key()};
+        final String[] acceptedListParams = {QueryParams.SCRIPTS.key(), QueryParams.VARIABLES.key()};
         filterObjectParams(parameters, document.getSet(), acceptedListParams);
 
 //        // Check if the scripts exist.
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/StudyManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/StudyManager.java
index 848cb8e5e2d..aebff77e9c9 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/StudyManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/StudyManager.java
@@ -170,6 +170,10 @@ Study resolveId(String studyStr, QueryOptions options, String userId, String org
         return studyDataResult.first();
     }
 
+    Study resolveId(CatalogFqn catalogFqn, JwtPayload payload) throws CatalogException {
+        return resolveId(catalogFqn, null, payload);
+    }
+
     Study resolveId(CatalogFqn catalogFqn, QueryOptions options, JwtPayload payload) throws CatalogException {
         OpenCGAResult<Study> studyDataResult = smartResolutor(catalogFqn, options, payload);
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index da1e10b0809..85bb74105f6 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -228,32 +228,293 @@ public OpenCGAResult<Workflow> update(String studyStr, String workflowId, Workfl
 
     @Override
     public DBIterator<Workflow> iterator(String studyStr, Query query, QueryOptions options, String token) throws CatalogException {
-        return null;
+        query = ParamUtils.defaultObject(query, Query::new);
+        options = ParamUtils.defaultObject(options, QueryOptions::new);
+
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+        Study study = catalogManager.getStudyManager().resolveId(studyFqn, null, tokenPayload);
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+
+        Query finalQuery = new Query(query);
+        fixQueryObject(finalQuery);
+        finalQuery.append(WorkflowDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid());
+
+        return getWorkflowDBAdaptor(organizationId).iterator(study.getUid(), finalQuery, options, userId);
     }
 
     @Override
-    public OpenCGAResult<Workflow> search(String studyId, Query query, QueryOptions options, String token) throws CatalogException {
-        return null;
+    public OpenCGAResult<Workflow> search(String studyStr, Query query, QueryOptions options, String token) throws CatalogException {
+        query = ParamUtils.defaultObject(query, Query::new);
+        options = ParamUtils.defaultObject(options, QueryOptions::new);
+
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+        String studyId = studyFqn.getStudyId();
+        String studyUuid = studyFqn.getStudyUuid();
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("studyStr", studyStr)
+                .append("query", new Query(query))
+                .append("options", options)
+                .append("token", token);
+        try {
+            Study study = catalogManager.getStudyManager().resolveId(studyFqn, tokenPayload);
+            studyId = study.getId();
+            studyUuid = study.getUuid();
+
+            fixQueryObject(query);
+            query.append(WorkflowDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid());
+
+            OpenCGAResult<Workflow> queryResult = getWorkflowDBAdaptor(organizationId).get(study.getUid(), query, options, userId);
+
+            auditManager.auditSearch(organizationId, userId, Enums.Resource.WORKFLOW, study.getId(), study.getUuid(), auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+
+            return queryResult;
+        } catch (CatalogException e) {
+            auditManager.auditSearch(organizationId, userId, Enums.Resource.WORKFLOW, studyId, studyUuid, auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            throw e;
+        }
     }
 
     @Override
-    public OpenCGAResult<?> distinct(String studyId, List<String> fields, Query query, String token) throws CatalogException {
-        return null;
+    public OpenCGAResult<?> distinct(String studyStr, List<String> fields, Query query, String token) throws CatalogException {
+        query = ParamUtils.defaultObject(query, Query::new);
+
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+
+        Study study = catalogManager.getStudyManager().resolveId(studyStr, userId, organizationId);
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("studyId", studyStr)
+                .append("fields", fields)
+                .append("query", new Query(query))
+                .append("token", token);
+        try {
+            fixQueryObject(query);
+
+            query.append(WorkflowDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid());
+            OpenCGAResult<?> result = getWorkflowDBAdaptor(organizationId).distinct(study.getUid(), fields, query, userId);
+
+            auditManager.auditDistinct(organizationId, userId, Enums.Resource.WORKFLOW, study.getId(), study.getUuid(), auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+
+            return result;
+        } catch (CatalogException e) {
+            auditManager.auditDistinct(organizationId, userId, Enums.Resource.WORKFLOW, study.getId(), study.getUuid(), auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            throw e;
+        }
     }
 
     @Override
-    public OpenCGAResult<Workflow> count(String studyId, Query query, String token) throws CatalogException {
-        return null;
+    public OpenCGAResult<Workflow> count(String studyStr, Query query, String token) throws CatalogException {
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+
+        Study study = catalogManager.getStudyManager().resolveId(studyStr, userId, organizationId);
+
+        query = new Query(ParamUtils.defaultObject(query, Query::new));
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("studyId", studyStr)
+                .append("query", query)
+                .append("token", token);
+        try {
+            fixQueryObject(query);
+
+            query.append(WorkflowDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid());
+            OpenCGAResult<Long> queryResultAux = getWorkflowDBAdaptor(organizationId).count(query, userId);
+
+            auditManager.auditCount(organizationId, userId, Enums.Resource.WORKFLOW, study.getId(), study.getUuid(), auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+
+            return new OpenCGAResult<>(queryResultAux.getTime(), queryResultAux.getEvents(), 0, Collections.emptyList(),
+                    queryResultAux.getNumMatches());
+        } catch (CatalogException e) {
+            auditManager.auditCount(organizationId, userId, Enums.Resource.WORKFLOW, study.getId(), study.getUuid(), auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            throw e;
+        }
     }
 
     @Override
     public OpenCGAResult delete(String studyStr, List<String> ids, QueryOptions options, String token) throws CatalogException {
-        return null;
+        return delete(studyStr, ids, options, false, token);
+    }
+
+    public OpenCGAResult delete(String studyStr, List<String> ids, ObjectMap params, boolean ignoreException, String token)
+            throws CatalogException {
+        if (ids == null || ListUtils.isEmpty(ids)) {
+            throw new CatalogException("Missing list of workflow ids");
+        }
+
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+        Study study = catalogManager.getStudyManager().resolveId(studyStr, userId, organizationId);
+
+        String operationId = UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.AUDIT);
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("study", studyStr)
+                .append("workflowIds", ids)
+                .append("params", params)
+                .append("ignoreException", ignoreException)
+                .append("token", token);
+
+        boolean checkPermissions;
+        try {
+            // If the user is the owner or the admin, we won't check if he has permissions for every single entry
+            long studyId = study.getUid();
+            checkPermissions = !authorizationManager.isAtLeastStudyAdministrator(organizationId, studyId, userId);
+        } catch (CatalogException e) {
+            auditManager.auditDelete(organizationId, operationId, userId, Enums.Resource.WORKFLOW, "", "", study.getId(), study.getUuid(),
+                    auditParams, new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            throw e;
+        }
+
+        auditManager.initAuditBatch(operationId);
+        OpenCGAResult result = OpenCGAResult.empty();
+        for (String id : ids) {
+            String workflowId = id;
+            String workflowUuid = "";
+            try {
+                OpenCGAResult<Workflow> internalResult = internalGet(organizationId, study.getUid(), id, INCLUDE_WORKFLOW_IDS, userId);
+                if (internalResult.getNumResults() == 0) {
+                    throw new CatalogException("Workflow '" + id + "' not found");
+                }
+                Workflow workflow = internalResult.first();
+
+                // We set the proper values for the audit
+                workflowId = workflow.getId();
+                workflowUuid = workflow.getUuid();
+
+                if (checkPermissions) {
+                    authorizationManager.checkWorkflowPermission(organizationId, study.getUid(), workflow.getUid(), userId,
+                            WorkflowPermissions.DELETE);
+                }
+
+                // Check if the workflow can be deleted
+                checkWorkflowCanBeDeleted(organizationId, study.getUid(), workflow, params.getBoolean(Constants.FORCE, false));
+
+                result.append(getWorkflowDBAdaptor(organizationId).delete(workflow));
+
+                auditManager.auditDelete(organizationId, operationId, userId, Enums.Resource.WORKFLOW, workflow.getId(), workflow.getUuid(),
+                        study.getId(), study.getUuid(), auditParams, new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+            } catch (CatalogException e) {
+                String errorMsg = "Cannot delete workflow " + workflowId + ": " + e.getMessage();
+
+                Event event = new Event(Event.Type.ERROR, workflowId, e.getMessage());
+                result.getEvents().add(event);
+                result.setNumErrors(result.getNumErrors() + 1);
+
+                logger.error(errorMsg);
+                auditManager.auditDelete(organizationId, operationId, userId, Enums.Resource.WORKFLOW, workflowId, workflowUuid,
+                        study.getId(), study.getUuid(), auditParams, new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            }
+        }
+        auditManager.finishAuditBatch(organizationId, operationId);
+
+        return endResult(result, ignoreException);
+    }
+
+    private void checkWorkflowCanBeDeleted(String organizationId, long uid, Workflow workflow, boolean force) {
+        return;
     }
 
     @Override
     public OpenCGAResult delete(String studyStr, Query query, QueryOptions options, String token) throws CatalogException {
-        return null;
+        return delete(studyStr, query, options, false, token);
+    }
+
+    public OpenCGAResult delete(String studyStr, Query query, ObjectMap params, boolean ignoreException, String token)
+            throws CatalogException {
+        Query finalQuery = new Query(ParamUtils.defaultObject(query, Query::new));
+        params = ParamUtils.defaultObject(params, ObjectMap::new);
+
+        OpenCGAResult result = OpenCGAResult.empty();
+
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+        Study study = catalogManager.getStudyManager().resolveId(studyStr, userId, organizationId);
+
+        String operationUuid = UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.AUDIT);
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("study", studyStr)
+                .append("query", new Query(query))
+                .append("params", params)
+                .append("ignoreException", ignoreException)
+                .append("token", token);
+
+        // If the user is the owner or the admin, we won't check if he has permissions for every single entry
+        boolean checkPermissions;
+
+        // We try to get an iterator containing all the workflows to be deleted
+        DBIterator<Workflow> iterator;
+        try {
+            fixQueryObject(finalQuery);
+            finalQuery.append(WorkflowDBAdaptor.QueryParams.STUDY_UID.key(), study.getUid());
+
+            iterator = getWorkflowDBAdaptor(organizationId).iterator(study.getUid(), finalQuery, INCLUDE_WORKFLOW_IDS, userId);
+
+            // If the user is the owner or the admin, we won't check if he has permissions for every single entry
+            long studyId = study.getUid();
+            checkPermissions = !authorizationManager.isAtLeastStudyAdministrator(organizationId, studyId, userId);
+        } catch (CatalogException e) {
+            auditManager.auditDelete(organizationId, operationUuid, userId, Enums.Resource.WORKFLOW, "", "", study.getId(), study.getUuid(),
+                    auditParams, new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            throw e;
+        }
+
+        auditManager.initAuditBatch(operationUuid);
+        while (iterator.hasNext()) {
+            Workflow workflow = iterator.next();
+
+            try {
+                if (checkPermissions) {
+                    authorizationManager.checkWorkflowPermission(organizationId, study.getUid(), workflow.getUid(), userId,
+                            WorkflowPermissions.DELETE);
+                }
+
+                // Check if the workflow can be deleted
+                checkWorkflowCanBeDeleted(organizationId, study.getUid(), workflow, params.getBoolean(Constants.FORCE, false));
+
+                result.append(getWorkflowDBAdaptor(organizationId).delete(workflow));
+
+                auditManager.auditDelete(organizationId, operationUuid, userId, Enums.Resource.WORKFLOW, workflow.getId(),
+                        workflow.getUuid(), study.getId(), study.getUuid(), auditParams,
+                        new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+            } catch (CatalogException e) {
+                String errorMsg = "Cannot delete workflow " + workflow.getId() + ": " + e.getMessage();
+
+                Event event = new Event(Event.Type.ERROR, workflow.getId(), e.getMessage());
+                result.getEvents().add(event);
+                result.setNumErrors(result.getNumErrors() + 1);
+
+                logger.error(errorMsg);
+                auditManager.auditDelete(organizationId, operationUuid, userId, Enums.Resource.WORKFLOW, workflow.getId(),
+                        workflow.getUuid(), study.getId(), study.getUuid(), auditParams,
+                        new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            }
+        }
+        auditManager.finishAuditBatch(organizationId, operationUuid);
+
+        return endResult(result, ignoreException);
     }
 
     @Override
@@ -303,8 +564,8 @@ private void validateNewWorkflow(Workflow workflow) throws CatalogParameterExcep
         if (CollectionUtils.isNotEmpty(workflow.getScripts()) && !main) {
             throw new CatalogParameterException("No main script found.");
         }
-        workflow.setDocker(workflow.getDocker() != null ? workflow.getDocker() : new WorkflowRepository(""));
-        if (StringUtils.isEmpty(workflow.getDocker().getImage()) && CollectionUtils.isEmpty(workflow.getScripts())) {
+        workflow.setRepository(workflow.getRepository() != null ? workflow.getRepository() : new WorkflowRepository(""));
+        if (StringUtils.isEmpty(workflow.getRepository().getImage()) && CollectionUtils.isEmpty(workflow.getScripts())) {
             throw new CatalogParameterException("No docker image or scripts found.");
         }
 
diff --git a/opencga-client/src/main/R/R/Workflow-methods.R b/opencga-client/src/main/R/R/Workflow-methods.R
index acda02de8d1..3addb897cc1 100644
--- a/opencga-client/src/main/R/R/Workflow-methods.R
+++ b/opencga-client/src/main/R/R/Workflow-methods.R
@@ -72,7 +72,7 @@ setMethod("workflowClient", "OpencgaR", function(OpencgaR, workflowId, workflows
         #' @param jobScheduledStartTime Time when the job is scheduled to start.
         #' @param jobPriority Priority of the job.
         #' @param jobDryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
-        #' @param data HRDetect analysis parameters.
+        #' @param data NextFlow run parameters.
         run=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory=NULL, subcategoryId=NULL,
                 action="run", params=params, httpMethod="POST", as.queryParam=NULL, ...),
 
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
index 58f83fa792f..5e5d5062edc 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
@@ -22,7 +22,7 @@
 import org.opencb.opencga.client.exceptions.ClientException;
 import org.opencb.opencga.client.rest.*;
 import org.opencb.opencga.core.models.job.Job;
-import org.opencb.opencga.core.models.variant.HRDetectAnalysisParams;
+import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
 import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
@@ -94,7 +94,7 @@ public RestResponse<Object> distinct(String field, ObjectMap params) throws Clie
 
     /**
      * Execute a Nextflow analysis.
-     * @param data HRDetect analysis parameters.
+     * @param data NextFlow run parameters.
      * @param params Map containing any of the following optional parameters.
      *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
      *       jobId: Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
@@ -108,7 +108,7 @@ public RestResponse<Object> distinct(String field, ObjectMap params) throws Clie
      * @return a RestResponse object.
      * @throws ClientException ClientException if there is any server error.
      */
-    public RestResponse<Job> run(HRDetectAnalysisParams data, ObjectMap params) throws ClientException {
+    public RestResponse<Job> run(NextFlowRunParams data, ObjectMap params) throws ClientException {
         params = params != null ? params : new ObjectMap();
         params.put("body", data);
         return execute("workflows", null, null, null, "run", params, POST, Job.class);
diff --git a/opencga-client/src/main/javascript/Workflow.js b/opencga-client/src/main/javascript/Workflow.js
index 64c855a09fc..29203f59fe6 100644
--- a/opencga-client/src/main/javascript/Workflow.js
+++ b/opencga-client/src/main/javascript/Workflow.js
@@ -70,7 +70,7 @@ export default class Workflow extends OpenCGAParentClass {
     }
 
     /** Execute a Nextflow analysis.
-    * @param {Object} data - HRDetect analysis parameters.
+    * @param {Object} data - NextFlow run parameters.
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
     * @param {String} [params.jobId] - Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
index 2ff82ef4192..1618e10883c 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
@@ -75,7 +75,7 @@ def run(self, data=None, **options):
         Execute a Nextflow analysis.
         PATH: /{apiVersion}/workflows/run
 
-        :param dict data: HRDetect analysis parameters. (REQUIRED)
+        :param dict data: NextFlow run parameters. (REQUIRED)
         :param str study: Study [[organization@]project:]study where study and
             project can be either the ID or UUID.
         :param str job_id: Job ID. It must be a unique string within the
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index 213c65c11e1..d5b58ace894 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -311,9 +311,11 @@ public class FieldConstants {
     public static final String WORKFLOW_ID_DESCRIPTION = "Workflow ID.";
     public static final String WORKFLOW_NAME_DESCRIPTION = "Workflow name.";
     public static final String WORKFLOW_TYPE_DESCRIPTION = "Workflow type. Valid values: NEXTFLOW.";
-    public static final String WORKFLOW_DOCKER_DESCRIPTION = "Workflow docker image to execute. If any, providing a list of scripts will"
-            + " not be mandatory.";
+    public static final String WORKFLOW_DRAFT_DESCRIPTION = "Flag indicating whether the workflow is still a draft or not.";
+    public static final String WORKFLOW_REPOSITORY_DESCRIPTION = "Workflow repository image to execute. If any, providing a list of"
+            + " scripts will not be mandatory.";
     public static final String WORKFLOW_SCRIPTS_DESCRIPTION = "List of scripts used by the Workflow.";
+    public static final String WORKFLOW_VARIABLES_DESCRIPTION = "List of variables accepted by the Workflow.";
     public static final String WORKFLOW_SOMATIC_DESCRIPTION = "Describes if the sample is somatic or not .";
     public static final String WORKFLOW_INDIVIDUAL_ID_DESCRIPTION = "Individual id of the sample.";
     public static final String WORKFLOW_FILE_IDS_DESCRIPTION = "File ids of the sample.";
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/NextFlowRunParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/NextFlowRunParams.java
index 8d99a80788c..d35494041e7 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/NextFlowRunParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/NextFlowRunParams.java
@@ -2,19 +2,23 @@
 
 import org.opencb.opencga.core.tools.ToolParams;
 
+import java.util.Map;
+
 public class NextFlowRunParams extends ToolParams {
 
     public static final String DESCRIPTION = "NextFlow run parameters";
 
     private String id;
     private Integer version;
+    private Map<String, String> params;
 
     public NextFlowRunParams() {
     }
 
-    public NextFlowRunParams(String id, Integer version) {
+    public NextFlowRunParams(String id, Integer version, Map<String, String> params) {
         this.id = id;
         this.version = version;
+        this.params = params;
     }
 
     @Override
@@ -22,6 +26,7 @@ public String toString() {
         final StringBuilder sb = new StringBuilder("NextFlowRunParams{");
         sb.append("id='").append(id).append('\'');
         sb.append(", version=").append(version);
+        sb.append(", params='").append(params).append('\'');
         sb.append('}');
         return sb.toString();
     }
@@ -43,4 +48,13 @@ public NextFlowRunParams setVersion(Integer version) {
         this.version = version;
         return this;
     }
+
+    public Map<String, String> getParams() {
+        return params;
+    }
+
+    public NextFlowRunParams setParams(Map<String, String> params) {
+        this.params = params;
+        return this;
+    }
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index 4a6f5d27898..6374b55ebcd 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -3,6 +3,7 @@
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
 import org.opencb.opencga.core.models.PrivateStudyUid;
+import org.opencb.opencga.core.models.study.Variable;
 
 import java.util.List;
 import java.util.Map;
@@ -23,19 +24,24 @@ public class Workflow extends PrivateStudyUid {
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
-    @DataField(id = "version", managed = true, indexed = true,
-            description = FieldConstants.GENERIC_VERSION_DESCRIPTION)
+    @DataField(id = "draft", description = FieldConstants.WORKFLOW_DRAFT_DESCRIPTION)
+    private boolean draft;
+
+    @DataField(id = "version", managed = true, indexed = true, description = FieldConstants.GENERIC_VERSION_DESCRIPTION)
     private int version;
 
     @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
     private Type type;
 
-    @DataField(id = "docker", description = FieldConstants.WORKFLOW_DOCKER_DESCRIPTION)
-    private WorkflowRepository docker;
+    @DataField(id = "repository", description = FieldConstants.WORKFLOW_REPOSITORY_DESCRIPTION)
+    private WorkflowRepository repository;
 
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
     private List<WorkflowScript> scripts;
 
+    @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
+    private List<Variable> variables;
+
     @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
 
@@ -52,14 +58,17 @@ public enum Type {
     public Workflow() {
     }
 
-    public Workflow(String id, String name, String description, Type type, WorkflowRepository docker, List<WorkflowScript> scripts,
-                    String creationDate, String modificationDate, Map<String, Object> attributes) {
+    public Workflow(String id, String name, String description, boolean draft, Type type, WorkflowRepository repository,
+                    List<WorkflowScript> scripts, List<Variable> variables, String creationDate, String modificationDate,
+                    Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
         this.description = description;
+        this.draft = draft;
         this.type = type;
-        this.docker = docker;
+        this.repository = repository;
         this.scripts = scripts;
+        this.variables = variables;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
         this.attributes = attributes;
@@ -72,10 +81,12 @@ public String toString() {
         sb.append(", uuid='").append(uuid).append('\'');
         sb.append(", name='").append(name).append('\'');
         sb.append(", description='").append(description).append('\'');
+        sb.append(", draft=").append(draft);
         sb.append(", version=").append(version);
         sb.append(", type=").append(type);
-        sb.append(", docker='").append(docker).append('\'');
+        sb.append(", repository=").append(repository);
         sb.append(", scripts=").append(scripts);
+        sb.append(", variables=").append(variables);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
         sb.append(", attributes=").append(attributes);
@@ -137,12 +148,30 @@ public Workflow setType(Type type) {
         return this;
     }
 
-    public WorkflowRepository getDocker() {
-        return docker;
+    public boolean isDraft() {
+        return draft;
+    }
+
+    public Workflow setDraft(boolean draft) {
+        this.draft = draft;
+        return this;
+    }
+
+    public WorkflowRepository getRepository() {
+        return repository;
+    }
+
+    public Workflow setRepository(WorkflowRepository repository) {
+        this.repository = repository;
+        return this;
+    }
+
+    public List<Variable> getVariables() {
+        return variables;
     }
 
-    public Workflow setDocker(WorkflowRepository docker) {
-        this.docker = docker;
+    public Workflow setVariables(List<Variable> variables) {
+        this.variables = variables;
         return this;
     }
 
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
index 4c2948cd196..7ede6a4a502 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -2,6 +2,7 @@
 
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
+import org.opencb.opencga.core.models.study.Variable;
 
 import java.util.List;
 import java.util.Map;
@@ -21,8 +22,14 @@ public class WorkflowCreateParams {
 //    @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
 //    private Workflow.Type type;
 
-    @DataField(id = "docker", description = FieldConstants.WORKFLOW_DOCKER_DESCRIPTION)
-    private WorkflowRepository docker;
+    @DataField(id = "draft", description = FieldConstants.WORKFLOW_DRAFT_DESCRIPTION)
+    private boolean draft;
+
+    @DataField(id = "repository", description = FieldConstants.WORKFLOW_REPOSITORY_DESCRIPTION)
+    private WorkflowRepository repository;
+
+    @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
+    private List<Variable> variables;
 
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
     private List<WorkflowScript> scripts;
@@ -39,12 +46,15 @@ public class WorkflowCreateParams {
     public WorkflowCreateParams() {
     }
 
-    public WorkflowCreateParams(String id, String name, String description, WorkflowRepository docker, List<WorkflowScript> scripts,
-                                String creationDate, String modificationDate, Map<String, Object> attributes) {
+    public WorkflowCreateParams(String id, String name, String description, boolean draft, WorkflowRepository repository,
+                                List<Variable> variables, List<WorkflowScript> scripts, String creationDate, String modificationDate,
+                                Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
         this.description = description;
-        this.docker = docker;
+        this.draft = draft;
+        this.repository = repository;
+        this.variables = variables;
         this.scripts = scripts;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
@@ -57,7 +67,9 @@ public String toString() {
         sb.append("id='").append(id).append('\'');
         sb.append(", name='").append(name).append('\'');
         sb.append(", description='").append(description).append('\'');
-        sb.append(", docker=").append(docker);
+        sb.append(", draft=").append(draft);
+        sb.append(", repository=").append(repository);
+        sb.append(", variables=").append(variables);
         sb.append(", scripts=").append(scripts);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
@@ -67,7 +79,8 @@ public String toString() {
     }
 
     public Workflow toWorkflow() {
-        return new Workflow(id, name, description, Workflow.Type.NEXTFLOW, docker, scripts, creationDate, modificationDate, attributes);
+        return new Workflow(id, name, description, draft, Workflow.Type.NEXTFLOW, repository, scripts, variables, creationDate,
+                modificationDate, attributes);
     }
 
     public String getId() {
@@ -97,12 +110,30 @@ public WorkflowCreateParams setDescription(String description) {
         return this;
     }
 
-    public WorkflowRepository getDocker() {
-        return docker;
+    public boolean isDraft() {
+        return draft;
+    }
+
+    public WorkflowCreateParams setDraft(boolean draft) {
+        this.draft = draft;
+        return this;
+    }
+
+    public WorkflowRepository getRepository() {
+        return repository;
+    }
+
+    public WorkflowCreateParams setRepository(WorkflowRepository repository) {
+        this.repository = repository;
+        return this;
+    }
+
+    public List<Variable> getVariables() {
+        return variables;
     }
 
-    public WorkflowCreateParams setDocker(WorkflowRepository docker) {
-        this.docker = docker;
+    public WorkflowCreateParams setVariables(List<Variable> variables) {
+        this.variables = variables;
         return this;
     }
 
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
index e89a2ab4350..4f407348ef0 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
@@ -2,6 +2,7 @@
 
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
+import org.opencb.opencga.core.models.study.Variable;
 
 import java.util.List;
 import java.util.Map;
@@ -14,12 +15,18 @@ public class WorkflowUpdateParams {
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
-    @DataField(id = "docker", description = FieldConstants.WORKFLOW_DOCKER_DESCRIPTION)
-    private WorkflowRepository docker;
+    @DataField(id = "draft", description = FieldConstants.WORKFLOW_DRAFT_DESCRIPTION)
+    private boolean draft;
+
+    @DataField(id = "repository", description = FieldConstants.WORKFLOW_REPOSITORY_DESCRIPTION)
+    private WorkflowRepository repository;
 
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
     private List<WorkflowScript> scripts;
 
+    @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
+    private List<Variable> variables;
+
     @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
 
@@ -32,12 +39,14 @@ public class WorkflowUpdateParams {
     public WorkflowUpdateParams() {
     }
 
-    public WorkflowUpdateParams(String name, String description, WorkflowRepository docker, List<WorkflowScript> scripts, String creationDate,
-                                String modificationDate, Map<String, Object> attributes) {
+    public WorkflowUpdateParams(String name, String description, boolean draft, WorkflowRepository repository, List<WorkflowScript> scripts,
+                                List<Variable> variables, String creationDate, String modificationDate, Map<String, Object> attributes) {
         this.name = name;
         this.description = description;
-        this.docker = docker;
+        this.draft = draft;
+        this.repository = repository;
         this.scripts = scripts;
+        this.variables = variables;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
         this.attributes = attributes;
@@ -48,8 +57,10 @@ public String toString() {
         final StringBuilder sb = new StringBuilder("WorkflowUpdateParams{");
         sb.append("name='").append(name).append('\'');
         sb.append(", description='").append(description).append('\'');
-        sb.append(", docker=").append(docker);
+        sb.append(", draft=").append(draft);
+        sb.append(", repository=").append(repository);
         sb.append(", scripts=").append(scripts);
+        sb.append(", variables=").append(variables);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
         sb.append(", attributes=").append(attributes);
@@ -75,12 +86,21 @@ public WorkflowUpdateParams setDescription(String description) {
         return this;
     }
 
-    public WorkflowRepository getDocker() {
-        return docker;
+    public boolean isDraft() {
+        return draft;
+    }
+
+    public WorkflowUpdateParams setDraft(boolean draft) {
+        this.draft = draft;
+        return this;
+    }
+
+    public WorkflowRepository getRepository() {
+        return repository;
     }
 
-    public WorkflowUpdateParams setDocker(WorkflowRepository docker) {
-        this.docker = docker;
+    public WorkflowUpdateParams setRepository(WorkflowRepository repository) {
+        this.repository = repository;
         return this;
     }
 
@@ -93,6 +113,15 @@ public WorkflowUpdateParams setScripts(List<WorkflowScript> scripts) {
         return this;
     }
 
+    public List<Variable> getVariables() {
+        return variables;
+    }
+
+    public WorkflowUpdateParams setVariables(List<Variable> variables) {
+        this.variables = variables;
+        return this;
+    }
+
     public String getCreationDate() {
         return creationDate;
     }
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
index 94c4e849fab..0c887f654ce 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
@@ -3,18 +3,13 @@
 import org.apache.commons.lang3.ObjectUtils;
 import org.opencb.commons.datastore.core.DataResult;
 import org.opencb.commons.datastore.core.QueryOptions;
-import org.opencb.opencga.analysis.variant.hrdetect.HRDetectAnalysis;
 import org.opencb.opencga.analysis.workflow.NextFlowExecutor;
 import org.opencb.opencga.catalog.managers.WorkflowManager;
 import org.opencb.opencga.catalog.utils.Constants;
 import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.exceptions.VersionException;
 import org.opencb.opencga.core.models.job.Job;
-import org.opencb.opencga.core.models.variant.HRDetectAnalysisParams;
-import org.opencb.opencga.core.models.workflow.Workflow;
-import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
-import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
-import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
+import org.opencb.opencga.core.models.workflow.*;
 import org.opencb.opencga.core.tools.annotations.*;
 
 import javax.servlet.http.HttpServletRequest;
@@ -100,8 +95,8 @@ public Response updateByPost(
             @ApiParam(value = ParamConstants.JOB_SCHEDULED_START_TIME_DESCRIPTION) @QueryParam(ParamConstants.JOB_SCHEDULED_START_TIME) String scheduledStartTime,
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
-            @ApiParam(value = HRDetectAnalysisParams.DESCRIPTION, required = true) HRDetectAnalysisParams params) {
-        return submitJob(HRDetectAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+            @ApiParam(value = NextFlowRunParams.DESCRIPTION, required = true) NextFlowRunParams params) {
+        return submitJob(NextFlowExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET

From c152132097417164f54046f4537af39ff5dbd3e2 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 3 Sep 2024 15:16:28 +0200
Subject: [PATCH 09/99] pom: change cellbase dependency, #TASK-6445

---
 .../analysis/tools/WorkflowExecutorTest.java  | 14 ++++++++++---
 .../resources/nextflow/pipeline_cat_file.nf   | 20 +++++++++++++++++++
 pom.xml                                       |  2 +-
 3 files changed, 32 insertions(+), 4 deletions(-)
 create mode 100644 opencga-analysis/src/test/resources/nextflow/pipeline_cat_file.nf

diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index 5ea6173f8a7..9553bdedf20 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -12,6 +12,8 @@
 import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.config.storage.StorageConfiguration;
 import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.file.File;
+import org.opencb.opencga.core.models.file.FileCreateParams;
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
 import org.opencb.opencga.core.models.workflow.WorkflowRepository;
@@ -56,7 +58,9 @@ public void nextflowScriptWithFilesTest() throws ToolException, CatalogException
         InputStream inputStream = StorageManager.class.getClassLoader().getResourceAsStream("storage-configuration.yml");
         StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
 
-        WorkflowCreateParams workflow = createDummyWorkflow();
+        catalogManager.getFileManager().create(studyFqn, new FileCreateParams().setPath("myfile.txt").setContent("hello world").setType(File.Type.FILE), false, ownerToken);
+
+        WorkflowCreateParams workflow = createDummyWorkflow("pipeline_cat_file.nf");
         catalogManager.getWorkflowManager().create(studyFqn, workflow.toWorkflow(), QueryOptions.empty(), ownerToken);
 
         Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
@@ -64,7 +68,7 @@ public void nextflowScriptWithFilesTest() throws ToolException, CatalogException
         StopWatch stopWatch = StopWatch.createStarted();
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
         Map<String, String> workflowParams = new HashMap<>();
-        workflowParams.put("file", "ocga://myfile.txt");
+        workflowParams.put("in", "ocga://myfile.txt");
         NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1, workflowParams);
         ObjectMap params = runParams.toObjectMap();
         params.put(ParamConstants.STUDY_PARAM, studyFqn);
@@ -99,7 +103,11 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
     }
 
     private WorkflowCreateParams createDummyWorkflow() throws IOException {
-        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("nextflow/pipeline.nf");
+        return createDummyWorkflow("pipeline.nf");
+    }
+
+    private WorkflowCreateParams createDummyWorkflow(String pipelineId) throws IOException {
+        InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("nextflow/" + pipelineId);
         String content = IOUtils.toString(inputStream, "UTF-8");
         return new WorkflowCreateParams()
                 .setId("workflow")
diff --git a/opencga-analysis/src/test/resources/nextflow/pipeline_cat_file.nf b/opencga-analysis/src/test/resources/nextflow/pipeline_cat_file.nf
new file mode 100644
index 00000000000..afae798e218
--- /dev/null
+++ b/opencga-analysis/src/test/resources/nextflow/pipeline_cat_file.nf
@@ -0,0 +1,20 @@
+#!/usr/bin/env nextflow
+
+params.in = "$baseDir/myfile.txt"
+
+process foo {
+  output:
+  stdout
+
+  script:
+  """
+  echo `cat $params.in` world > file.out
+  """
+}
+
+/*
+ * Define the workflow
+ */
+workflow {
+    foo
+}
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 69bbd8f1151..80e730b9b64 100644
--- a/pom.xml
+++ b/pom.xml
@@ -46,7 +46,7 @@
 
         <pyopencga.version>3.3.0_dev</pyopencga.version>
         <opencgar.version>3.3.0_dev</opencgar.version>
-        <cellbase.version>6.2.0-SNAPSHOT</cellbase.version>
+        <cellbase.version>6.3.0-SNAPSHOT</cellbase.version>
         <biodata.version>3.3.0-SNAPSHOT</biodata.version>
         <java-common-libs.version>5.3.0-SNAPSHOT</java-common-libs.version>
         <iva.version>3.3.0-SNAPSHOT</iva.version>

From 0732dd3a6977d3f4ba6f1b02cba827b8dc031a5a Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 3 Sep 2024 16:28:20 +0200
Subject: [PATCH 10/99] cicd: remove init docker from being built, #TASK-6445

---
 .github/workflows/task.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/task.yml b/.github/workflows/task.yml
index cc8470b747a..496e45ac6d7 100644
--- a/.github/workflows/task.yml
+++ b/.github/workflows/task.yml
@@ -25,5 +25,5 @@ jobs:
     uses: opencb/java-common-libs/.github/workflows/deploy-docker-hub-workflow.yml@develop
     needs: test
     with:
-      cli: python3 ./build/cloud/docker/docker-build.py push --images base,init --tag ${{ github.ref_name }}
+      cli: python3 ./build/cloud/docker/docker-build.py push --images base --tag ${{ github.ref_name }}
     secrets: inherit

From 5d3156e9112f085551b298b8da689eb5a20136a6 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 4 Sep 2024 11:27:50 +0200
Subject: [PATCH 11/99] catalog: fix workflow indexes, #TASK-6445

---
 .../src/main/resources/catalog-indexes.txt            | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/opencga-catalog/src/main/resources/catalog-indexes.txt b/opencga-catalog/src/main/resources/catalog-indexes.txt
index e27276e6ab8..43d58a92972 100644
--- a/opencga-catalog/src/main/resources/catalog-indexes.txt
+++ b/opencga-catalog/src/main/resources/catalog-indexes.txt
@@ -235,7 +235,7 @@
 
 {"collections": ["interpretation", "interpretation_archive"], "fields": {"uuid": 1, "version": 1}, "options": {"unique": true}}
 {"collections": ["interpretation", "interpretation_archive"], "fields": {"uid": 1, "version": 1}, "options": {"unique": true}}
-{"collections": ["interpretation", "interpretation_archive"], "fields": {"id": 1, "version": 1, "studyUid": 1}, "options": {"unique": true}}
+{"collections": ["interpretation", "interpretation_archive"], "fields": {"id": 1, "studyUid": 1, "version": 1}, "options": {"unique": true}}
 {"collections": ["interpretation", "interpretation_archive"], "fields": {"clinicalAnalysisId": 1, "studyUid": 1}, "options": {}}
 {"collections": ["interpretation", "interpretation_archive"], "fields": {"analyst.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["interpretation", "interpretation_archive"], "fields": {"method.name": 1, "studyUid": 1}, "options": {}}
@@ -262,8 +262,9 @@
 {"collections": ["audit"], "fields": {"date": 1, "studyUuid": 1}, "options": {}}
 
 {"collections": ["workflow", "workflow_archive"], "fields": {"uid": 1, "version": 1}, "options": {"unique": true}}
-{"collections": ["workflow", "workflow_archive"], "fields": {"id": 1, "version": 1}, "options": {"unique": true}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"id": 1, "studyUid": 1, "version": 1}, "options": {"unique": true}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"uuid": 1, "version": 1}, "options": {"unique": true}}
-{"collections": ["workflow", "workflow_archive"], "fields": {"type": 1}, "options": {}}
-{"collections": ["workflow", "workflow_archive"], "fields": {"_creationDate": 1}, "options": {}}
-{"collections": ["workflow", "workflow_archive"], "fields": {"_modificationDate": 1}, "options": {}}
\ No newline at end of file
+{"collections": ["workflow", "workflow_archive"], "fields": {"type": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"_creationDate": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"_modificationDate": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"draft": 1, "studyUid": 1}, "options": {}}
\ No newline at end of file

From aa3edc0a12d83b88cbcc82f41526ed4b471ee6da Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 13 Sep 2024 11:22:53 +0200
Subject: [PATCH 12/99] analysis: change nextflow executor id, #TASK-6445

---
 .../org/opencb/opencga/analysis/workflow/NextFlowExecutor.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 029511581a3..494c2e08aff 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -41,7 +41,7 @@
 @Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.WORKFLOW, description = NextFlowExecutor.DESCRIPTION)
 public class NextFlowExecutor extends OpenCgaToolScopeStudy {
 
-    public final static String ID = "nextflow-run";
+    public final static String ID = "nextflow";
     public static final String DESCRIPTION = "Execute a Nextflow analysis.";
 
     @ToolParams

From 1b1f4becc742a38af73c996b252e8a80ae6e36e9 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 13 Sep 2024 14:57:18 +0200
Subject: [PATCH 13/99] catalog: add basic tests for workflows, #TASK-6445

---
 .../catalog/db/api/WorkflowDBAdaptor.java     |   1 +
 .../db/mongodb/FamilyMongoDBAdaptor.java      |   2 +-
 .../db/mongodb/IndividualMongoDBAdaptor.java  |   2 +-
 .../mongodb/InterpretationMongoDBAdaptor.java |   2 +-
 .../db/mongodb/PanelMongoDBAdaptor.java       |   2 +-
 .../db/mongodb/SampleMongoDBAdaptor.java      |   2 +-
 .../SnapshotVersionedMongoDBAdaptor.java      |   3 +-
 .../db/mongodb/WorkflowMongoDBAdaptor.java    |   6 +-
 .../catalog/managers/WorkflowManager.java     |  16 ++-
 .../catalog/managers/WorkflowManagerTest.java | 130 ++++++++++++++++++
 .../opencga/core/common/JacksonUtils.java     |   3 +
 .../core/models/workflow/Workflow.java        |  13 ++
 12 files changed, 171 insertions(+), 11 deletions(-)
 create mode 100644 opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
index a50d88c409e..45e4e52af06 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
@@ -22,6 +22,7 @@ enum QueryParams implements QueryParam {
         ID("id", TEXT, ""),
         UID("uid", LONG, ""),
         UUID("uuid", TEXT, ""),
+        NAME("name", TEXT, ""),
         DESCRIPTION("description", TEXT, ""),
         DRAFT("draft", BOOLEAN, ""),
         TYPE("type", TEXT, ""),
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/FamilyMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/FamilyMongoDBAdaptor.java
index 9e8c35d00ab..163e3ad8116 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/FamilyMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/FamilyMongoDBAdaptor.java
@@ -228,7 +228,7 @@ private Family insert(ClientSession clientSession, long studyUid, Family family,
         familyDocument.put(PERMISSION_RULES_APPLIED, Collections.emptyList());
 
         logger.debug("Inserting family '{}' ({})...", family.getId(), family.getUid());
-        versionedMongoDBAdaptor.insert(clientSession, familyDocument);
+        versionedMongoDBAdaptor.insert(clientSession, familyDocument, family.getRelease());
         logger.debug("Family '{}' successfully inserted", family.getId());
 
         // Add family reference to the members
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/IndividualMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/IndividualMongoDBAdaptor.java
index 13dbb40741c..2823f04ef96 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/IndividualMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/IndividualMongoDBAdaptor.java
@@ -197,7 +197,7 @@ Individual insert(ClientSession clientSession, long studyId, Individual individu
         individualDocument.put(PERMISSION_RULES_APPLIED, Collections.emptyList());
 
         logger.debug("Inserting individual '{}' ({})...", individual.getId(), individual.getUid());
-        versionedMongoDBAdaptor.insert(clientSession, individualDocument);
+        versionedMongoDBAdaptor.insert(clientSession, individualDocument, individual.getRelease());
         logger.debug("Individual '{}' successfully inserted", individual.getId());
 
         if (individual.getSamples() != null && !individual.getSamples().isEmpty()) {
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/InterpretationMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/InterpretationMongoDBAdaptor.java
index 3d78516dd55..090c10d0e50 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/InterpretationMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/InterpretationMongoDBAdaptor.java
@@ -265,7 +265,7 @@ Interpretation insert(ClientSession clientSession, long studyId, Interpretation
         interpretationObject.put(LAST_OF_VERSION, true);
         interpretationObject.put(LAST_OF_RELEASE, true);
 
-        versionedMongoDBAdaptor.insert(clientSession, interpretationObject);
+        versionedMongoDBAdaptor.insert(clientSession, interpretationObject, interpretation.getRelease());
 
         return interpretation;
     }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/PanelMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/PanelMongoDBAdaptor.java
index d82535b9351..0f2efa3a9ad 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/PanelMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/PanelMongoDBAdaptor.java
@@ -135,7 +135,7 @@ void insert(ClientSession clientSession, long studyUid, Panel panel) throws Cata
         logger.debug("Inserting panel '{}' ({})", panel.getId(), panel.getUid());
 
         Document panelDocument = getPanelDocumentForInsertion(clientSession, panel, studyUid);
-        versionedMongoDBAdaptor.insert(clientSession, panelDocument);
+        versionedMongoDBAdaptor.insert(clientSession, panelDocument, panel.getRelease());
         logger.info("Panel '" + panel.getId() + "(" + panel.getUid() + ")' successfully created");
     }
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SampleMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SampleMongoDBAdaptor.java
index 198c9fce456..63dec1c6c52 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SampleMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SampleMongoDBAdaptor.java
@@ -187,7 +187,7 @@ Sample insert(ClientSession clientSession, long studyUid, Sample sample, List<Va
         sampleObject.put(PRIVATE_INDIVIDUAL_UID, individualUid);
 
         logger.debug("Inserting sample '{}' ({})...", sample.getId(), sample.getUid());
-        versionedMongoDBAdaptor.insert(clientSession, sampleObject);
+        versionedMongoDBAdaptor.insert(clientSession, sampleObject, sample.getRelease());
         logger.debug("Sample '{}' successfully inserted", sample.getId());
 
         if (individualUid > 0) {
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
index 8a4ac1ed734..32f08943d4c 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/SnapshotVersionedMongoDBAdaptor.java
@@ -136,11 +136,12 @@ DBIterator<T> iterator(ClientSession session, Query query, QueryOptions options)
                 throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException;
     }
 
-    protected void insert(ClientSession session, Document document) {
+    protected void insert(ClientSession session, Document document, int release) {
         String uuid = getClientSessionUuid(session);
         document.put(VERSION, 1);
         document.put(LAST_OF_VERSION, true);
         document.put(LAST_OF_RELEASE, true);
+        document.put(RELEASE_FROM_VERSION, Collections.singletonList(release));
         document.put(PRIVATE_TRANSACTION_ID, uuid);
         collection.insert(session, document, QueryOptions.empty());
         archiveCollection.insert(session, document, QueryOptions.empty());
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index 00304341049..fda0f046177 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -83,6 +83,7 @@ Workflow insert(ClientSession clientSession, long studyUid, Workflow workflow) t
         long uid = getNewUid(clientSession);
         workflow.setUid(uid);
         workflow.setStudyUid(studyUid);
+        workflow.setRelease(dbAdaptorFactory.getCatalogStudyDBAdaptor().getCurrentRelease(clientSession, studyUid));
 
         Document workflowObject = workflowConverter.convertToStorageType(workflow);
 
@@ -92,7 +93,7 @@ Workflow insert(ClientSession clientSession, long studyUid, Workflow workflow) t
                 ? TimeUtils.toDate(workflow.getModificationDate()) : TimeUtils.getDate());
 
         logger.debug("Inserting workflow '{}' ({})...", workflow.getId(), workflow.getUid());
-        versionedMongoDBAdaptor.insert(clientSession, workflowObject);
+        versionedMongoDBAdaptor.insert(clientSession, workflowObject, workflow.getRelease());
         logger.debug("Workflow '{}' successfully inserted", workflow.getId());
 
         return workflow;
@@ -323,7 +324,7 @@ private UpdateDocument parseAndValidateUpdateParams(ObjectMap parameters, QueryO
         final String[] acceptedBooleanParams = {QueryParams.DRAFT.key()};
         filterBooleanParams(parameters, document.getSet(), acceptedBooleanParams);
 
-        final String[] acceptedParams = {QueryParams.DESCRIPTION.key(), QueryParams.COMMAND_LINE.key()};
+        final String[] acceptedParams = {QueryParams.NAME.key(), QueryParams.DESCRIPTION.key(), QueryParams.COMMAND_LINE.key()};
         filterStringParams(parameters, document.getSet(), acceptedParams);
 
         final String[] acceptedMapParams = {QueryParams.ATTRIBUTES.key()};
@@ -513,6 +514,7 @@ protected Bson parseQuery(Query query, Document extraQuery, String user)
                     case RELEASE:
                     case VERSION:
                     case TYPE:
+                    case DRAFT:
                         addAutoOrQuery(queryParam.key(), queryParam.key(), queryCopy, queryParam.type(), andBsonList);
                         break;
                     default:
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 85bb74105f6..7f36e4597a3 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -175,7 +175,7 @@ public OpenCGAResult<Workflow> update(String studyStr, String workflowId, Workfl
         ObjectMap updateMap = null;
         try {
             if (updateParams != null) {
-                updateMap = new ObjectMap(getUpdateObjectMapper().writeValueAsString(this));
+                updateMap = new ObjectMap(getUpdateObjectMapper().writeValueAsString(updateParams));
             }
         } catch (JsonProcessingException e) {
             throw new CatalogException("Could not parse WorkflowUpdateParams object: " + e.getMessage(), e);
@@ -548,7 +548,13 @@ private WorkflowDBAdaptor.QueryParams getFieldFilter(List<String> idList) throws
 
     private void validateNewWorkflow(Workflow workflow) throws CatalogParameterException {
         ParamUtils.checkIdentifier(workflow.getId(), ID.key());
-        ParamUtils.checkObj(workflow.getType(), TYPE.key());
+        if (Workflow.Type.values().length > 1) {
+            ParamUtils.checkObj(workflow.getType(), TYPE.key());
+        } else if (workflow.getType() == null) {
+            // TODO: Remove this condition in the future once we know we support more than one type.
+            // If there is only one valid type, we set it
+            workflow.setType(Workflow.Type.NEXTFLOW);
+        }
         workflow.setScripts(workflow.getScripts() != null ? workflow.getScripts() : Collections.emptyList());
         boolean main = false;
         for (WorkflowScript script : workflow.getScripts()) {
@@ -566,7 +572,11 @@ private void validateNewWorkflow(Workflow workflow) throws CatalogParameterExcep
         }
         workflow.setRepository(workflow.getRepository() != null ? workflow.getRepository() : new WorkflowRepository(""));
         if (StringUtils.isEmpty(workflow.getRepository().getImage()) && CollectionUtils.isEmpty(workflow.getScripts())) {
-            throw new CatalogParameterException("No docker image or scripts found.");
+            throw new CatalogParameterException("No repository image or scripts found.");
+        }
+        if (StringUtils.isNotEmpty(workflow.getRepository().getImage()) && CollectionUtils.isNotEmpty(workflow.getScripts())) {
+            throw new CatalogParameterException("Both repository image and scripts found. Please, either add scripts or a repository"
+                    + " image.");
         }
 
         workflow.setName(ParamUtils.defaultString(workflow.getName(), workflow.getId()));
diff --git a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
new file mode 100644
index 00000000000..8f5f58e7ef5
--- /dev/null
+++ b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
@@ -0,0 +1,130 @@
+package org.opencb.opencga.catalog.managers;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.opencb.commons.datastore.core.Query;
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
+import org.opencb.opencga.catalog.exceptions.CatalogException;
+import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowRepository;
+import org.opencb.opencga.core.models.workflow.WorkflowScript;
+import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
+import org.opencb.opencga.core.response.OpenCGAResult;
+import org.opencb.opencga.core.testclassification.duration.MediumTests;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.junit.Assert.*;
+
+@Category(MediumTests.class)
+public class WorkflowManagerTest extends AbstractManagerTest {
+
+    private WorkflowManager workflowManager;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        workflowManager = catalogManager.getWorkflowManager();
+    }
+
+    @Test
+    public void createWorkflowTest() throws CatalogException {
+        Workflow workflow = new Workflow()
+                .setId("workflow")
+                .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
+        OpenCGAResult<Workflow> result = workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
+        assertEquals(1, result.getNumResults());
+        assertNotNull(result.first());
+        assertEquals(workflow.getId(), result.first().getId());
+
+        // Add repository to workflow
+        workflow.setId("workflow2");
+        workflow.setRepository(new WorkflowRepository("blabla"));
+        CatalogException catalogException = assertThrows(CatalogException.class,
+                () -> workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken));
+        assertTrue(catalogException.getMessage().contains("script") && catalogException.getMessage().contains("repository"));
+
+        // Remove script from workflow
+        workflow.setScripts(Collections.emptyList());
+        result = workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
+        assertEquals(1, result.getNumResults());
+        assertNotNull(result.first());
+        assertEquals(workflow.getId(), result.first().getId());
+
+        // Remove script and add two scripts with 2 mains
+        workflow.setId("workflow3");
+        workflow.setRepository(null);
+        workflow.setScripts(Arrays.asList(
+                new WorkflowScript("script1", "echo 'Hello'", true),
+                new WorkflowScript("script2", "echo 'World'", true)
+        ));
+        catalogException = assertThrows(CatalogException.class,
+                () -> workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken));
+        assertTrue(catalogException.getMessage().contains("script") && catalogException.getMessage().contains("main"));
+
+        // Add one single script without main
+        workflow.setScripts(Collections.singletonList(
+                new WorkflowScript("script1", "echo 'Hello'", false)
+        ));
+        catalogException = assertThrows(CatalogException.class,
+                () -> workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken));
+        assertTrue(catalogException.getMessage().contains("script") && catalogException.getMessage().contains("main"));
+    }
+
+    @Test
+    public void workflowSearchTest() throws CatalogException {
+        Workflow workflow = new Workflow()
+                .setId("workflow")
+                .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
+        workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
+
+        workflow = new Workflow()
+                .setId("workflow2")
+                .setDraft(true)
+                .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
+        workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
+
+        OpenCGAResult<Workflow> search = workflowManager.search(studyFqn, new Query(), QueryOptions.empty(), ownerToken);
+        assertEquals(2, search.getNumResults());
+
+        Query query = new Query(WorkflowDBAdaptor.QueryParams.DRAFT.key(), true);
+        search = workflowManager.search(studyFqn, query, QueryOptions.empty(), ownerToken);
+        assertEquals(1, search.getNumResults());
+        assertEquals("workflow2", search.first().getId());
+        assertTrue(search.first().isDraft());
+
+        query = new Query(WorkflowDBAdaptor.QueryParams.DRAFT.key(), false);
+        search = workflowManager.search(studyFqn, query, QueryOptions.empty(), ownerToken);
+        assertEquals(1, search.getNumResults());
+        assertEquals("workflow", search.first().getId());
+        assertFalse(search.first().isDraft());
+    }
+
+    @Test
+    public void updateWorkflowTest() throws CatalogException {
+        Workflow workflow = new Workflow()
+                .setId("workflow")
+                .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
+        workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
+
+        WorkflowUpdateParams updateParams = new WorkflowUpdateParams()
+                .setName("newName")
+                .setDraft(true)
+                .setCreationDate("20240101000000")
+                .setModificationDate("20240201000000")
+                .setDescription("description");
+
+        OpenCGAResult<Workflow> update = workflowManager.update(studyFqn, workflow.getId(), updateParams, INCLUDE_RESULT, ownerToken);
+        assertEquals(1, update.getNumUpdated());
+        Workflow updatedWorkflow = update.first();
+        assertEquals(updateParams.getName(), updatedWorkflow.getName());
+        assertEquals(updateParams.isDraft(), updatedWorkflow.isDraft());
+        assertEquals(updateParams.getCreationDate(), updatedWorkflow.getCreationDate());
+        assertEquals(updateParams.getModificationDate(), updatedWorkflow.getModificationDate());
+        assertEquals(updateParams.getDescription(), updatedWorkflow.getDescription());
+    }
+
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/common/JacksonUtils.java b/opencga-core/src/main/java/org/opencb/opencga/core/common/JacksonUtils.java
index e5f542454ee..6b8ca6ee2be 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/common/JacksonUtils.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/common/JacksonUtils.java
@@ -45,6 +45,7 @@
 import org.opencb.opencga.core.models.sample.Sample;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.models.study.VariableSet;
+import org.opencb.opencga.core.models.workflow.Workflow;
 
 import javax.ws.rs.ext.ContextResolver;
 import java.io.IOException;
@@ -109,6 +110,7 @@ private static ObjectMapper generateUpdateObjectMapper(JsonFactory jf) {
         objectMapper.addMixIn(VariableSet.class, PrivateUidMixin.class);
         objectMapper.addMixIn(ClinicalAnalysis.class, PrivateUidMixin.class);
         objectMapper.addMixIn(Interpretation.class, PrivateUidMixin.class);
+        objectMapper.addMixIn(Workflow.class, PrivateUidMixin.class);
 
         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 
@@ -143,6 +145,7 @@ private static ObjectMapper generateOpenCGAObjectMapper(JsonFactory jf) {
         objectMapper.addMixIn(VariableSet.class, PrivateUidMixin.class);
         objectMapper.addMixIn(ClinicalAnalysis.class, PrivateUidMixin.class);
         objectMapper.addMixIn(Interpretation.class, PrivateUidMixin.class);
+        objectMapper.addMixIn(Workflow.class, PrivateUidMixin.class);
         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
 
         return objectMapper;
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index 6374b55ebcd..759255bc3aa 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -30,6 +30,9 @@ public class Workflow extends PrivateStudyUid {
     @DataField(id = "version", managed = true, indexed = true, description = FieldConstants.GENERIC_VERSION_DESCRIPTION)
     private int version;
 
+    @DataField(id = "release", managed = true, indexed = true, description = FieldConstants.GENERIC_RELEASE_DESCRIPTION)
+    private int release;
+
     @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
     private Type type;
 
@@ -83,6 +86,7 @@ public String toString() {
         sb.append(", description='").append(description).append('\'');
         sb.append(", draft=").append(draft);
         sb.append(", version=").append(version);
+        sb.append(", release=").append(release);
         sb.append(", type=").append(type);
         sb.append(", repository=").append(repository);
         sb.append(", scripts=").append(scripts);
@@ -139,6 +143,15 @@ public Workflow setVersion(int version) {
         return this;
     }
 
+    public int getRelease() {
+        return release;
+    }
+
+    public Workflow setRelease(int release) {
+        this.release = release;
+        return this;
+    }
+
     public Type getType() {
         return type;
     }

From 1a2ef4559e0213fced058f9d4b2bf675bab00f8e Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 16 Sep 2024 12:54:04 +0200
Subject: [PATCH 14/99] catalog: implement delete workflow, #TASK-6445

---
 .../db/mongodb/WorkflowMongoDBAdaptor.java    | 57 +++++++++++++++++--
 .../mongodb/converters/WorkflowConverter.java | 10 ++++
 .../catalog/managers/ResourceManager.java     |  6 +-
 .../catalog/managers/WorkflowManager.java     | 16 ++++--
 .../catalog/managers/WorkflowManagerTest.java | 15 +++++
 .../opencga/core/api/FieldConstants.java      |  2 +-
 .../core/models/workflow/Workflow.java        | 24 +++++++-
 .../models/workflow/WorkflowCreateParams.java |  4 +-
 .../models/workflow/WorkflowInternal.java     | 37 ++++++++++++
 9 files changed, 154 insertions(+), 17 deletions(-)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowInternal.java

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index fda0f046177..c3c9543c6ad 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -163,7 +163,7 @@ public DBIterator<Workflow> iterator(Query query, QueryOptions options)
     }
 
     @Override
-    public DBIterator nativeIterator(Query query, QueryOptions options)
+    public DBIterator<Document> nativeIterator(Query query, QueryOptions options)
             throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
         QueryOptions queryOptions = options != null ? new QueryOptions(options) : new QueryOptions();
         queryOptions.put(NATIVE_QUERY, true);
@@ -172,7 +172,7 @@ public DBIterator nativeIterator(Query query, QueryOptions options)
     }
 
     @Override
-    public DBIterator nativeIterator(long studyUid, Query query, QueryOptions options, String user)
+    public DBIterator<Document> nativeIterator(long studyUid, Query query, QueryOptions options, String user)
             throws CatalogDBException, CatalogAuthorizationException, CatalogParameterException {
         QueryOptions queryOptions = options != null ? new QueryOptions(options) : new QueryOptions();
         queryOptions.put(NATIVE_QUERY, true);
@@ -372,13 +372,60 @@ private UpdateDocument parseAndValidateUpdateParams(ObjectMap parameters, QueryO
     }
 
     @Override
-    public OpenCGAResult<Workflow> delete(Workflow id) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
+    public OpenCGAResult<Workflow> delete(Workflow workflow)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        try {
+            Query query = new Query()
+                    .append(QueryParams.UID.key(), workflow.getUid())
+                    .append(QueryParams.STUDY_UID.key(), workflow.getStudyUid());
+            OpenCGAResult<Document> result = nativeGet(query, new QueryOptions());
+            if (result.getNumResults() == 0) {
+                throw new CatalogDBException("Could not find workflow " + workflow.getId() + " with uid " + workflow.getUid());
+            }
+            return runTransaction(clientSession -> privateDelete(clientSession, result.first()));
+        } catch (CatalogDBException e) {
+            logger.error("Could not delete workflow {}: {}", workflow.getId(), e.getMessage(), e);
+            throw new CatalogDBException("Could not delete workflow " + workflow.getId() + ": " + e.getMessage(), e);
+        }
     }
 
     @Override
     public OpenCGAResult<Workflow> delete(Query query) throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
-        return null;
+        try (DBIterator<Document> iterator = nativeIterator(query, new QueryOptions())) {
+            OpenCGAResult<Workflow> result = OpenCGAResult.empty(Workflow.class);
+            while (iterator.hasNext()) {
+                Document workflow = iterator.next();
+                String workflowId = workflow.getString(QueryParams.ID.key());
+
+                try {
+                    result.append(runTransaction(clientSession -> privateDelete(clientSession, workflow)));
+                } catch (CatalogDBException | CatalogParameterException | CatalogAuthorizationException e) {
+                    logger.error("Could not delete workflow {}: {}", workflowId, e.getMessage(), e);
+                    result.getEvents().add(new Event(Event.Type.ERROR, workflowId, e.getMessage()));
+                    result.setNumMatches(result.getNumMatches() + 1);
+                }
+            }
+            return result;
+        }
+    }
+
+    OpenCGAResult<Workflow> privateDelete(ClientSession clientSession, Document workflowDocument)
+            throws CatalogDBException, CatalogParameterException, CatalogAuthorizationException {
+        long tmpStartTime = startQuery();
+
+        String workflowId = workflowDocument.getString(QueryParams.ID.key());
+        long workflowUid = workflowDocument.getLong(PRIVATE_UID);
+        long studyUid = workflowDocument.getLong(PRIVATE_STUDY_UID);
+
+        logger.debug("Deleting workflow {} ({})", workflowId, workflowUid);
+        // Delete workflow
+        Query workflowQuery = new Query()
+                .append(QueryParams.UID.key(), workflowUid)
+                .append(QueryParams.STUDY_UID.key(), studyUid);
+        Bson bsonQuery = parseQuery(workflowQuery);
+        versionedMongoDBAdaptor.delete(clientSession, bsonQuery);
+        logger.debug("Workflow {}({}) deleted", workflowId, workflowUid);
+        return endWrite(tmpStartTime, 1, 0, 0, 1, Collections.emptyList());
     }
 
     @Override
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
index 5fda14d7e78..182385965bf 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/converters/WorkflowConverter.java
@@ -1,5 +1,6 @@
 package org.opencb.opencga.catalog.db.mongodb.converters;
 
+import org.bson.Document;
 import org.opencb.opencga.core.models.workflow.Workflow;
 
 public class WorkflowConverter extends OpenCgaMongoConverter<Workflow> {
@@ -7,4 +8,13 @@ public class WorkflowConverter extends OpenCgaMongoConverter<Workflow> {
     public WorkflowConverter() {
         super(Workflow.class);
     }
+
+    @Override
+    public Document convertToStorageType(Workflow object) {
+        Document document = super.convertToStorageType(object);
+        // Keep long values in uids
+        document.put("uid", object.getUid());
+        document.put("studyUid", object.getStudyUid());
+        return document;
+    }
 }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/ResourceManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/ResourceManager.java
index 9584a4a7301..d4cb2bd92e3 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/ResourceManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/ResourceManager.java
@@ -266,7 +266,11 @@ public abstract OpenCGAResult<?> distinct(String studyId, List<String> fields, Q
      */
     public abstract OpenCGAResult<R> count(String studyId, Query query, String token) throws CatalogException;
 
-    public abstract OpenCGAResult delete(String studyStr, List<String> ids, QueryOptions options, String token)
+    public OpenCGAResult<R> delete(String studyStr, String id, QueryOptions options, String token) throws CatalogException {
+        return delete(studyStr, Collections.singletonList(id), options, token);
+    }
+
+    public abstract OpenCGAResult<R> delete(String studyStr, List<String> ids, QueryOptions options, String token)
             throws CatalogException;
 
     /**
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 7f36e4597a3..70c97d133db 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -24,12 +24,14 @@
 import org.opencb.opencga.catalog.utils.ParamUtils;
 import org.opencb.opencga.catalog.utils.UuidUtils;
 import org.opencb.opencga.core.api.ParamConstants;
+import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Configuration;
 import org.opencb.opencga.core.models.AclEntryList;
 import org.opencb.opencga.core.models.AclParams;
 import org.opencb.opencga.core.models.JwtPayload;
 import org.opencb.opencga.core.models.audit.AuditRecord;
 import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.common.InternalStatus;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.models.study.StudyPermissions;
 import org.opencb.opencga.core.models.workflow.*;
@@ -49,7 +51,7 @@
 public class WorkflowManager extends ResourceManager<Workflow> {
 
     public static final QueryOptions INCLUDE_WORKFLOW_IDS = new QueryOptions(QueryOptions.INCLUDE, Arrays.asList(ID.key(), UID.key(),
-            UUID.key(), VERSION.key()));
+            UUID.key(), VERSION.key(), STUDY_UID.key()));
 
     private final CatalogIOManager catalogIOManager;
     private final IOManagerFactory ioManagerFactory;
@@ -144,7 +146,7 @@ public OpenCGAResult<Workflow> create(String studyStr, Workflow workflow, QueryO
                     StudyPermissions.Permissions.WRITE_WORKFLOWS);
 
             // 2. Validate the workflow parameters
-            validateNewWorkflow(workflow);
+            validateNewWorkflow(workflow, userId);
 
             // 3. We insert the workflow
             OpenCGAResult<Workflow> insert = getWorkflowDBAdaptor(organizationId).insert(study.getUid(), workflow, options);
@@ -349,11 +351,11 @@ public OpenCGAResult<Workflow> count(String studyStr, Query query, String token)
     }
 
     @Override
-    public OpenCGAResult delete(String studyStr, List<String> ids, QueryOptions options, String token) throws CatalogException {
+    public OpenCGAResult<Workflow> delete(String studyStr, List<String> ids, QueryOptions options, String token) throws CatalogException {
         return delete(studyStr, ids, options, false, token);
     }
 
-    public OpenCGAResult delete(String studyStr, List<String> ids, ObjectMap params, boolean ignoreException, String token)
+    public OpenCGAResult<Workflow> delete(String studyStr, List<String> ids, ObjectMap params, boolean ignoreException, String token)
             throws CatalogException {
         if (ids == null || ListUtils.isEmpty(ids)) {
             throw new CatalogException("Missing list of workflow ids");
@@ -386,7 +388,7 @@ public OpenCGAResult delete(String studyStr, List<String> ids, ObjectMap params,
         }
 
         auditManager.initAuditBatch(operationId);
-        OpenCGAResult result = OpenCGAResult.empty();
+        OpenCGAResult<Workflow> result = OpenCGAResult.empty(Workflow.class);
         for (String id : ids) {
             String workflowId = id;
             String workflowUuid = "";
@@ -546,7 +548,7 @@ private WorkflowDBAdaptor.QueryParams getFieldFilter(List<String> idList) throws
         return idQueryParam;
     }
 
-    private void validateNewWorkflow(Workflow workflow) throws CatalogParameterException {
+    private void validateNewWorkflow(Workflow workflow, String userId) throws CatalogParameterException {
         ParamUtils.checkIdentifier(workflow.getId(), ID.key());
         if (Workflow.Type.values().length > 1) {
             ParamUtils.checkObj(workflow.getType(), TYPE.key());
@@ -586,6 +588,8 @@ private void validateNewWorkflow(Workflow workflow) throws CatalogParameterExcep
         workflow.setCreationDate(ParamUtils.checkDateOrGetCurrentDate(workflow.getCreationDate(), CREATION_DATE.key()));
         workflow.setModificationDate(ParamUtils.checkDateOrGetCurrentDate(workflow.getModificationDate(), MODIFICATION_DATE.key()));
         workflow.setAttributes(ParamUtils.defaultObject(workflow.getAttributes(), Collections.emptyMap()));
+        workflow.setInternal(new WorkflowInternal(new InternalStatus(InternalStatus.READY), TimeUtils.getTime(), TimeUtils.getTime(),
+                userId));
     }
 
     // **************************   ACLs  ******************************** //
diff --git a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
index 8f5f58e7ef5..9625b012444 100644
--- a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
+++ b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
@@ -127,4 +127,19 @@ public void updateWorkflowTest() throws CatalogException {
         assertEquals(updateParams.getDescription(), updatedWorkflow.getDescription());
     }
 
+    @Test
+    public void deleteWorkflowTest() throws CatalogException {
+        Workflow workflow = new Workflow()
+                .setId("workflow")
+                .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
+        workflowManager.create(studyFqn, workflow, QueryOptions.empty(), ownerToken);
+
+        OpenCGAResult<Workflow> result = workflowManager.delete(studyFqn, workflow.getId(), QueryOptions.empty(), ownerToken);
+        assertEquals(1, result.getNumDeleted());
+
+        CatalogException exception = assertThrows(CatalogException.class,
+                () -> workflowManager.get(studyFqn, workflow.getId(), QueryOptions.empty(), ownerToken));
+        assertTrue(exception.getMessage().contains("not found"));
+    }
+
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index d5b58ace894..d1a03fd4507 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -316,11 +316,11 @@ public class FieldConstants {
             + " scripts will not be mandatory.";
     public static final String WORKFLOW_SCRIPTS_DESCRIPTION = "List of scripts used by the Workflow.";
     public static final String WORKFLOW_VARIABLES_DESCRIPTION = "List of variables accepted by the Workflow.";
+    public static final String WORKFLOW_INTERNAL_DESCRIPTION = "Workflow internal information.";
     public static final String WORKFLOW_SOMATIC_DESCRIPTION = "Describes if the sample is somatic or not .";
     public static final String WORKFLOW_INDIVIDUAL_ID_DESCRIPTION = "Individual id of the sample.";
     public static final String WORKFLOW_FILE_IDS_DESCRIPTION = "File ids of the sample.";
     public static final String WORKFLOW_COHORT_IDS_DESCRIPTION = "Cohort ids of the sample.";
-    public static final String WORKFLOW_INTERNAL_DESCRIPTION = "Sample internal information.";
     public static final String WORKFLOW_EXTERNAL_SOURCE_DESCRIPTION = "The external source from where the example was imported.";
 
     //FileInternal
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index 759255bc3aa..e8bfbc11208 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -45,6 +45,9 @@ public class Workflow extends PrivateStudyUid {
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
     private List<Variable> variables;
 
+    @DataField(id = "internal", description = FieldConstants.WORKFLOW_INTERNAL_DESCRIPTION)
+    private WorkflowInternal internal;
+
     @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
 
@@ -62,8 +65,8 @@ public Workflow() {
     }
 
     public Workflow(String id, String name, String description, boolean draft, Type type, WorkflowRepository repository,
-                    List<WorkflowScript> scripts, List<Variable> variables, String creationDate, String modificationDate,
-                    Map<String, Object> attributes) {
+                    List<WorkflowScript> scripts, List<Variable> variables, WorkflowInternal internal, String creationDate,
+                    String modificationDate, Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
         this.description = description;
@@ -72,6 +75,7 @@ public Workflow(String id, String name, String description, boolean draft, Type
         this.repository = repository;
         this.scripts = scripts;
         this.variables = variables;
+        this.internal = internal;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
         this.attributes = attributes;
@@ -91,6 +95,7 @@ public String toString() {
         sb.append(", repository=").append(repository);
         sb.append(", scripts=").append(scripts);
         sb.append(", variables=").append(variables);
+        sb.append(", internal=").append(internal);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
         sb.append(", attributes=").append(attributes);
@@ -107,6 +112,12 @@ public Workflow setId(String id) {
         return this;
     }
 
+    @Override
+    public Workflow setUid(long uid) {
+        super.setUid(uid);
+        return this;
+    }
+
     public String getUuid() {
         return uuid;
     }
@@ -197,6 +208,15 @@ public Workflow setScripts(List<WorkflowScript> scripts) {
         return this;
     }
 
+    public WorkflowInternal getInternal() {
+        return internal;
+    }
+
+    public Workflow setInternal(WorkflowInternal internal) {
+        this.internal = internal;
+        return this;
+    }
+
     public String getCreationDate() {
         return creationDate;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
index 7ede6a4a502..e6f2bcd0105 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -79,8 +79,8 @@ public String toString() {
     }
 
     public Workflow toWorkflow() {
-        return new Workflow(id, name, description, draft, Workflow.Type.NEXTFLOW, repository, scripts, variables, creationDate,
-                modificationDate, attributes);
+        return new Workflow(id, name, description, draft, Workflow.Type.NEXTFLOW, repository, scripts, variables, new WorkflowInternal(),
+                creationDate, modificationDate, attributes);
     }
 
     public String getId() {
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowInternal.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowInternal.java
new file mode 100644
index 00000000000..10f58513e53
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowInternal.java
@@ -0,0 +1,37 @@
+package org.opencb.opencga.core.models.workflow;
+
+import org.opencb.opencga.core.models.common.Internal;
+import org.opencb.opencga.core.models.common.InternalStatus;
+
+public class WorkflowInternal extends Internal {
+
+    private String registrationUserId;
+
+    public WorkflowInternal() {
+    }
+
+    public WorkflowInternal(InternalStatus status, String registrationDate, String lastModified, String registrationUserId) {
+        super(status, registrationDate, lastModified);
+        this.registrationUserId = registrationUserId;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowInternal{");
+        sb.append("registrationUserId='").append(registrationUserId).append('\'');
+        sb.append(", status=").append(status);
+        sb.append(", registrationDate='").append(registrationDate).append('\'');
+        sb.append(", lastModified='").append(lastModified).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getRegistrationUserId() {
+        return registrationUserId;
+    }
+
+    public WorkflowInternal setRegistrationUserId(String registrationUserId) {
+        this.registrationUserId = registrationUserId;
+        return this;
+    }
+}

From f9578e09a115f5c7a4f7914dce524ab9fe17ea1a Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Tue, 17 Sep 2024 01:44:49 +0100
Subject: [PATCH 15/99] Implement a python script to build Docker images for
 user's custom tools

---
 .../custom-tool-docker-builder/README.md      |  11 ++
 .../custom-tool-docker-build.py               | 172 ++++++++++++++++++
 2 files changed, 183 insertions(+)
 create mode 100644 opencga-app/app/cloud/docker/custom-tool-docker-builder/README.md
 create mode 100755 opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py

diff --git a/opencga-app/app/cloud/docker/custom-tool-docker-builder/README.md b/opencga-app/app/cloud/docker/custom-tool-docker-builder/README.md
new file mode 100644
index 00000000000..643bdfb7969
--- /dev/null
+++ b/opencga-app/app/cloud/docker/custom-tool-docker-builder/README.md
@@ -0,0 +1,11 @@
+## Description
+The custom-tool-docker-builder script is designed to automate the process of building Docker images for custom tools. 
+
+It includes steps to:
+* configure the Docker environment and create the Dockerfile
+* build the Docker image with specified Ubuntu dependencies
+* install python dependencies using requirements.txt
+* install R dependencies using install.r
+
+This script helps streamline the Docker image creation process, ensuring consistency and efficiency.
+
diff --git a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
new file mode 100755
index 00000000000..a4ef8a36c8b
--- /dev/null
+++ b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import sys
+
+## Configure command-line options
+parser = argparse.ArgumentParser()
+parser.add_argument("action", help="Action to execute", choices=["dockerfile", "build", "push"], default="dockerfile")
+parser.add_argument("-t", "--custom-tool-dir", help="Path to the tool folder, this MUST contain a requirement.txt file")
+parser.add_argument("--apt-get", help="List of apt-get packages to install")
+parser.add_argument("-o", "--organisation", help="Organisation of the Docker image", default="opencb")
+parser.add_argument("-n", "--name", help="Name of the docker image, e.g. my-tool")
+parser.add_argument("-v", "--version", help="Tag of the docker image, e.g. v1.0.0", default="1.0.0")
+parser.add_argument("-l", "--latest", help="Make the docker image latest, e.g. v1.0.0", default="False")
+parser.add_argument("-u", "--username", help="Username to login to the docker registry")
+parser.add_argument("-p", "--password", help="Password to login to the docker registry",)
+# parser.add_argument('--docker-build-args',
+#                     help="Additional build arguments to pass to the docker build command. Usage: --docker-build-args='ARGS' e.g: --docker-build-args='--no-cache'",
+#                     default="")
+parser.add_argument('--server', help="Docker registry server", default="docker.io")
+
+## Some ANSI colors to print shell output
+shell_colors = {
+    'red': '\033[91m',
+    'green': '\033[92m',
+    'blue': '\033[94m',
+    'magenta': '\033[95m',
+    'bold': '\033[1m',
+    'reset': '\033[0m'
+}
+
+
+def error(message):
+    sys.stderr.write(shell_colors['red'] + 'ERROR: %s\n' % message + shell_colors['reset'])
+    sys.exit(2)
+
+
+def print_header(str):
+    print(shell_colors['magenta'] + "*************************************************" + shell_colors['reset'])
+    print(shell_colors['magenta'] + str + shell_colors['reset'])
+    print(shell_colors['magenta'] + "*************************************************" + shell_colors['reset'])
+
+
+def run(command):
+    print(shell_colors['bold'] + command + shell_colors['reset'])
+    code = os.system(command)
+    if code != 0:
+        error("Error executing: " + command)
+
+
+def login(loginRequired=False):
+    if args.username is None or args.password is None:
+        if loginRequired:
+            error("Username and password are required")
+        else:
+            return
+
+    code = os.system("docker login -u " + args.username + " --password " + args.password)
+    if code != 0:
+        error("Error executing: '" + "docker login -u " + args.username + " --password " + args.password + "'")
+
+def get_docker_image_id():
+    print_header('Getting docker image ID: ...')
+
+    ## Check if the required parameters are set
+    if args.organisation is None or args.organisation == "" or args.name is None or args.name == "" or args.version is None or args.version == "":
+        error("Docker organisation, name and version are all required")
+
+    return args.organisation + "/" + args.name + ":" + args.version
+
+
+def dockerfile():
+    # print_header('Creating Dockerfile ...')
+    print(shell_colors['blue'] + "Creating Dockerfile  ..." + shell_colors['reset'])
+
+    with open(custom_build_folder + "/Dockerfile", "w") as f:
+        f.write("FROM ubuntu:24.04\n\n")
+        f.write("COPY . /app\n\n")
+
+        # Update Ubuntu and install base libraries
+        f.write("RUN apt update && apt -y upgrade && apt install -y python3 python3-pip r-base && \\ \n")
+
+        # Install user's apt dependencies
+        if args.apt_get is not None and not args.apt_get == "":
+            f.write("apt install -y " + args.apt_get.replace(",", " ") + " && \\ \n")
+
+        # Install Python dependencies
+        if os.path.isfile(custom_build_folder + "/requirements.txt"):
+            f.write("pip3 install -r /app/requirements.txt --break-system-packages && \\ \n")
+
+        # Install R dependencies
+        if os.path.isfile(custom_build_folder + "/install.r"):
+            f.write("Rscript /app/install.r && \\ \n")
+
+        f.write("rm -rf /var/lib/apt/lists/* \n\n")
+
+        f.write("USER opencga\n\n")
+        f.write("WORKDIR /app\n\n")
+        f.write("CMD bash\n")
+
+def build():
+    image = get_docker_image_id()
+    print(shell_colors['blue'] + "Building " + image + " ..." + shell_colors['reset'])
+
+    command = ("docker build"
+               + " -t " + image
+               + " -f " + custom_build_folder +  "/Dockerfile"
+               # + " " + args.docker_build_args + " "
+               + " " + custom_build_folder)
+    run(command)
+
+def tag_latest(image):
+    # if server:
+    #     print("Don't use tag latest in server " + server)
+    #     return
+    latest_tag = os.popen(("curl -s https://registry.hub.docker.com/v1/repositories/" + args.organisation + "/" + args.name + "/tags"
+                           + " | jq -r .[].name"
+                           + " | grep -v latest"
+                           + " | grep -v hdp"
+                           + " | grep -v dev"
+                           + " | sort -r -h"
+                           + " | head"))
+    if args.version >= latest_tag.read():
+        print_header("Pushing latest tag to Docker Hub...")
+        run("docker tag " + image + " " + args.organisation + "/" + args.name + ":latest")
+        run("docker push " + args.organisation + "/" + args.name + ":latest")
+    else:
+        print("Don't use tag " + args.version + " as 'latest'")
+
+def push():
+    image = get_docker_image_id()
+    print(shell_colors['blue'] + "Pushing to Docker Hub image: " + image + shell_colors['reset'])
+
+    # if server:
+    #     run("docker tag " + image + ":" + tag + " " + server + image + ":" + tag)
+    # run("docker push " + server + image + ":" + tag)
+    run("docker push " + image)
+    if args.latest == True:
+        tag_latest(image)
+
+
+## Parse command-line parameters and init basedir, tag and build_folder
+args = parser.parse_args()
+
+# 1. Set build folder to default value if not set
+if args.custom_tool_dir is not None and not args.custom_tool_dir == "":
+    custom_build_folder = args.custom_tool_dir
+    if not os.path.isdir(custom_build_folder):
+        error("Custom tool folder does not exist: " + custom_build_folder)
+else:
+    error("Custom tool folder is required")
+
+# 2. Set docker server
+# if args.server != "docker.io":
+#     server = args.server + "/"
+# else:
+#     server = ""
+
+## Execute the action
+if args.action == "dockerfile":
+    dockerfile()
+elif args.action == "build":
+    dockerfile()
+    build()
+elif args.action == "push":
+    login(loginRequired=True)
+    dockerfile()
+    build()
+    push()
+else:
+    error("Unknown action: " + args.action)

From 1253359e33e91bc66b17f537b5fa0666985f72c7 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Tue, 17 Sep 2024 03:04:37 +0100
Subject: [PATCH 16/99] Add missing Workflow indexes

---
 opencga-catalog/src/main/resources/catalog-indexes.txt | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/opencga-catalog/src/main/resources/catalog-indexes.txt b/opencga-catalog/src/main/resources/catalog-indexes.txt
index 43d58a92972..68b95c84215 100644
--- a/opencga-catalog/src/main/resources/catalog-indexes.txt
+++ b/opencga-catalog/src/main/resources/catalog-indexes.txt
@@ -264,7 +264,11 @@
 {"collections": ["workflow", "workflow_archive"], "fields": {"uid": 1, "version": 1}, "options": {"unique": true}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"id": 1, "studyUid": 1, "version": 1}, "options": {"unique": true}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"uuid": 1, "version": 1}, "options": {"unique": true}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"name": 1, "studyUid": 1}, "options": {"unique": true}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"type": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"tags": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"scripts.fileName": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"draft": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"internal.registrationUserId": 1, "studyUid": 1}, "options": {}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"_creationDate": 1, "studyUid": 1}, "options": {}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"_modificationDate": 1, "studyUid": 1}, "options": {}}
-{"collections": ["workflow", "workflow_archive"], "fields": {"draft": 1, "studyUid": 1}, "options": {}}
\ No newline at end of file

From 0f2e4f39d54a4c740e9f7890abaa0043a6b3e375 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 17 Sep 2024 12:05:32 +0200
Subject: [PATCH 17/99] core: add new binary executor, #TASK-6445

---
 .../analysis/binary/BinaryExecutor.java       | 97 +++++++++++++++++++
 .../app/cli/main/OpenCgaCompleter.java        |  2 +-
 .../app/cli/main/OpencgaCliOptionsParser.java |  1 +
 .../main/executors/JobsCommandExecutor.java   | 50 ++++++++++
 .../cli/main/options/JobsCommandOptions.java  | 58 +++++++++++
 opencga-client/src/main/R/R/Job-methods.R     | 15 +++
 .../client/rest/clients/JobClient.java        | 23 +++++
 opencga-client/src/main/javascript/Job.js     | 19 ++++
 .../pyopencga/rest_clients/job_client.py      | 25 +++++
 .../core/models/job/JobRunDockerParams.java   | 56 +++++++++++
 .../core/models/job/JobRunGitParams.java      | 44 +++++++++
 .../opencga/core/models/job/JobRunParams.java | 56 +++++++++++
 .../core/config/ConfigurationTest.java        | 12 +++
 .../opencga/server/rest/JobWSServer.java      | 20 ++++
 14 files changed, 477 insertions(+), 1 deletion(-)
 create mode 100644 opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunDockerParams.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunGitParams.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunParams.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
new file mode 100644
index 00000000000..a92a270b15f
--- /dev/null
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
@@ -0,0 +1,97 @@
+package org.opencb.opencga.analysis.binary;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.StopWatch;
+import org.opencb.commons.utils.DockerUtils;
+import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
+import org.opencb.opencga.analysis.utils.InputFileUtils;
+import org.opencb.opencga.core.common.TimeUtils;
+import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.file.File;
+import org.opencb.opencga.core.models.job.JobRunDockerParams;
+import org.opencb.opencga.core.models.job.JobRunParams;
+import org.opencb.opencga.core.tools.annotations.Tool;
+import org.opencb.opencga.core.tools.annotations.ToolParams;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.*;
+
+@Tool(id = BinaryExecutor.ID, resource = Enums.Resource.JOB, description = BinaryExecutor.DESCRIPTION)
+public class BinaryExecutor extends OpenCgaToolScopeStudy {
+
+    public final static String ID = "binary";
+    public static final String DESCRIPTION = "Execute an analysis from a custom binary.";
+
+    @ToolParams
+    protected JobRunParams runParams = new JobRunParams();
+
+    private String cliParams;
+    // Build list of inputfiles in case we need to specifically mount them in read only mode
+    List<AbstractMap.SimpleEntry<String, String>> inputBindings;
+    private String dockerImage;
+
+    private final static Logger logger = LoggerFactory.getLogger(BinaryExecutor.class);
+
+    @Override
+    protected void check() throws Exception {
+        super.check();
+
+        // Check any condition
+        if (runParams == null) {
+            throw new ToolException("Missing runParams");
+        }
+        if (StringUtils.isEmpty(runParams.getCommandLine())) {
+            throw new ToolException("Missing commandLine");
+        }
+        if (runParams.getDocker() == null || StringUtils.isEmpty(runParams.getDocker().getId())) {
+            runParams.setDocker(new JobRunDockerParams("opencb/opencga-ext-tools", "3.2.1", null));
+        }
+        if (!runParams.getDocker().getId().contains("/")) {
+            throw new ToolException("Missing repository organization. Format for the docker image should be 'organization/image'");
+        }
+        this.dockerImage = runParams.getDocker().getId();
+        if (StringUtils.isNotEmpty(runParams.getDocker().getTag())) {
+            this.dockerImage += ":" + runParams.getDocker().getTag();
+        }
+
+        // Build input bindings
+        this.inputBindings = new LinkedList<>();
+        InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
+
+        StringBuilder cliParamsBuilder = new StringBuilder();
+        String[] params = runParams.getCommandLine().split(" ");
+        Map<String, String> inputDirectoryMounts = new HashMap<>();
+        for (String param : params) {
+            if (inputFileUtils.isValidOpenCGAFile(param)) {
+                File file = inputFileUtils.getOpenCGAFile(study, param, token);
+                Path parent = Paths.get(file.getUri()).getParent();
+                if (!inputDirectoryMounts.containsKey(parent.toString())) {
+                    inputDirectoryMounts.put(parent.toString(), "/data/input" + inputDirectoryMounts.size());
+                }
+                String directoryMount = inputDirectoryMounts.get(parent.toString());
+                inputBindings.add(new AbstractMap.SimpleEntry<>(parent.toString(), directoryMount));
+                cliParamsBuilder.append(directoryMount).append("/").append(file.getName()).append(" ");
+            } else {
+                cliParamsBuilder.append(param).append(" ");
+            }
+        }
+        this.cliParams = cliParamsBuilder.toString();
+    }
+
+    @Override
+    protected void run() throws Exception {
+        // Build output binding
+        AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(getOutDir().toAbsolutePath().toString(),
+                "/data/output");
+
+        StopWatch stopWatch = StopWatch.createStarted();
+        String cmdline = DockerUtils.run(dockerImage, inputBindings, outputBinding, cliParams, null);
+        logger.info("Docker command line: " + cmdline);
+        logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
+    }
+
+}
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
index 4d1ed716a48..d3da3e09871 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
@@ -49,7 +49,7 @@ public abstract class OpenCgaCompleter implements Completer {
             .map(Candidate::new)
             .collect(toList());
 
-    private List<Candidate> jobsList = asList( "acl-update","create","distinct","retry","search","top","acl","delete","info","update","kill","log-head","log-tail")
+    private List<Candidate> jobsList = asList( "acl-update","create","distinct","retry","run","search","top","acl","delete","info","update","kill","log-head","log-tail")
             .stream()
             .map(Candidate::new)
             .collect(toList());
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
index d99dbba3488..16376431714 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
@@ -154,6 +154,7 @@ public OpencgaCliOptionsParser() {
         jobsSubCommands.addCommand("create", jobsCommandOptions.createCommandOptions);
         jobsSubCommands.addCommand("distinct", jobsCommandOptions.distinctCommandOptions);
         jobsSubCommands.addCommand("retry", jobsCommandOptions.retryCommandOptions);
+        jobsSubCommands.addCommand("run", jobsCommandOptions.runCommandOptions);
         jobsSubCommands.addCommand("search", jobsCommandOptions.searchCommandOptions);
         jobsSubCommands.addCommand("top", jobsCommandOptions.topCommandOptions);
         jobsSubCommands.addCommand("acl", jobsCommandOptions.aclCommandOptions);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
index cf28e7983bf..e30abec6bcb 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
@@ -23,6 +23,9 @@
 import org.opencb.opencga.core.models.job.JobAclUpdateParams;
 import org.opencb.opencga.core.models.job.JobCreateParams;
 import org.opencb.opencga.core.models.job.JobRetryParams;
+import org.opencb.opencga.core.models.job.JobRunDockerParams;
+import org.opencb.opencga.core.models.job.JobRunGitParams;
+import org.opencb.opencga.core.models.job.JobRunParams;
 import org.opencb.opencga.core.models.job.JobTop;
 import org.opencb.opencga.core.models.job.JobUpdateParams;
 import org.opencb.opencga.core.models.job.ToolInfo;
@@ -79,6 +82,9 @@ public void execute() throws Exception {
             case "retry":
                 queryResponse = retry();
                 break;
+            case "run":
+                queryResponse = run();
+                break;
             case "search":
                 queryResponse = search();
                 break;
@@ -268,6 +274,50 @@ private RestResponse<Job> retry() throws Exception {
         return openCGAClient.getJobClient().retry(jobRetryParams, queryParams);
     }
 
+    private RestResponse<Job> run() throws Exception {
+        logger.debug("Executing run in Jobs command line");
+
+        JobsCommandOptions.RunCommandOptions commandOptions = jobsCommandOptions.runCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("jobId", commandOptions.jobId);
+        queryParams.putIfNotEmpty("jobDescription", commandOptions.jobDescription);
+        queryParams.putIfNotEmpty("jobDependsOn", commandOptions.jobDependsOn);
+        queryParams.putIfNotEmpty("jobTags", commandOptions.jobTags);
+        queryParams.putIfNotEmpty("jobScheduledStartTime", commandOptions.jobScheduledStartTime);
+        queryParams.putIfNotEmpty("jobPriority", commandOptions.jobPriority);
+        queryParams.putIfNotNull("jobDryRun", commandOptions.jobDryRun);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        JobRunParams jobRunParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<Job> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/jobs/run"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            jobRunParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), JobRunParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotEmpty(beanParams, "commandLine",commandOptions.commandLine, true);
+            putNestedIfNotEmpty(beanParams, "docker.id",commandOptions.dockerId, true);
+            putNestedIfNotEmpty(beanParams, "docker.tag",commandOptions.dockerTag, true);
+            putNestedIfNotEmpty(beanParams, "docker.token",commandOptions.dockerToken, true);
+            putNestedIfNotEmpty(beanParams, "git.repository",commandOptions.gitRepository, true);
+            putNestedIfNotEmpty(beanParams, "git.reference",commandOptions.gitReference, true);
+
+            jobRunParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), JobRunParams.class);
+        }
+        return openCGAClient.getJobClient().run(jobRunParams, queryParams);
+    }
+
     private RestResponse<Job> search() throws Exception {
         logger.debug("Executing search in Jobs command line");
 
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
index 327d9487dfb..9f7e2928f6c 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
@@ -37,6 +37,7 @@ public class JobsCommandOptions extends CustomJobsCommandOptions {
         public CreateCommandOptions createCommandOptions;
         public DistinctCommandOptions distinctCommandOptions;
         public RetryCommandOptions retryCommandOptions;
+        public RunCommandOptions runCommandOptions;
         public SearchCommandOptions searchCommandOptions;
         public TopCommandOptions topCommandOptions;
         public AclCommandOptions aclCommandOptions;
@@ -55,6 +56,7 @@ public JobsCommandOptions(CommonCommandOptions commonCommandOptions, JCommander
         this.createCommandOptions = new CreateCommandOptions();
         this.distinctCommandOptions = new DistinctCommandOptions();
         this.retryCommandOptions = new RetryCommandOptions();
+        this.runCommandOptions = new RunCommandOptions();
         this.searchCommandOptions = new SearchCommandOptions();
         this.topCommandOptions = new TopCommandOptions();
         this.aclCommandOptions = new AclCommandOptions();
@@ -276,6 +278,62 @@ public class RetryCommandOptions {
     
     }
 
+    @Parameters(commandNames = {"run"}, commandDescription ="Execute an analysis from a custom binary.")
+    public class RunCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--job-id"}, description = "Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.", required = false, arity = 1)
+        public String jobId; 
+    
+        @Parameter(names = {"--job-description"}, description = "Job description", required = false, arity = 1)
+        public String jobDescription; 
+    
+        @Parameter(names = {"--job-depends-on"}, description = "Comma separated list of existing job IDs the job will depend on.", required = false, arity = 1)
+        public String jobDependsOn; 
+    
+        @Parameter(names = {"--job-tags"}, description = "Job tags", required = false, arity = 1)
+        public String jobTags; 
+    
+        @Parameter(names = {"--job-scheduled-start-time"}, description = "Time when the job is scheduled to start.", required = false, arity = 1)
+        public String jobScheduledStartTime; 
+    
+        @Parameter(names = {"--job-priority"}, description = "Priority of the job", required = false, arity = 1)
+        public String jobPriority; 
+    
+        @Parameter(names = {"--job-dry-run"}, description = "Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.", required = false, arity = 1)
+        public Boolean jobDryRun; 
+    
+        @Parameter(names = {"--command-line"}, description = "The body web service commandLine parameter", required = false, arity = 1)
+        public String commandLine;
+    
+        @Parameter(names = {"--docker-id"}, description = "The body web service id parameter", required = false, arity = 1)
+        public String dockerId;
+    
+        @Parameter(names = {"--docker-tag"}, description = "The body web service tag parameter", required = false, arity = 1)
+        public String dockerTag;
+    
+        @Parameter(names = {"--docker-token"}, description = "The body web service token parameter", required = false, arity = 1)
+        public String dockerToken;
+    
+        @Parameter(names = {"--git-repository"}, description = "The body web service repository parameter", required = false, arity = 1)
+        public String gitRepository;
+    
+        @Parameter(names = {"--git-reference"}, description = "The body web service reference parameter", required = false, arity = 1)
+        public String gitReference;
+    
+    }
+
     @Parameters(commandNames = {"search"}, commandDescription ="Job search method")
     public class SearchCommandOptions {
     
diff --git a/opencga-client/src/main/R/R/Job-methods.R b/opencga-client/src/main/R/R/Job-methods.R
index 32df3f06506..48d4d12f2f5 100644
--- a/opencga-client/src/main/R/R/Job-methods.R
+++ b/opencga-client/src/main/R/R/Job-methods.R
@@ -23,6 +23,7 @@
 #' | create | /{apiVersion}/jobs/create | study, body[*] |
 #' | distinct | /{apiVersion}/jobs/distinct | study, otherStudies, id, uuid, toolId, toolType, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted, field[*] |
 #' | retry | /{apiVersion}/jobs/retry | jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, study, body[*] |
+#' | run | /{apiVersion}/jobs/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | search | /{apiVersion}/jobs/search | include, exclude, limit, skip, count, study, otherStudies, id, uuid, toolId, toolType, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted |
 #' | top | /{apiVersion}/jobs/top | limit, study, internalStatus, priority, userId, toolId |
 #' | acl | /{apiVersion}/jobs/{jobs}/acl | jobs[*], member, silent |
@@ -95,6 +96,20 @@ setMethod("jobClient", "OpencgaR", function(OpencgaR, job, jobs, members, endpoi
         retry=fetchOpenCGA(object=OpencgaR, category="jobs", categoryId=NULL, subcategory=NULL, subcategoryId=NULL,
                 action="retry", params=params, httpMethod="POST", as.queryParam=NULL, ...),
 
+        #' @section Endpoint /{apiVersion}/jobs/run:
+        #' Execute an analysis from a custom binary.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param jobId Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+        #' @param jobDescription Job description.
+        #' @param jobDependsOn Comma separated list of existing job IDs the job will depend on.
+        #' @param jobTags Job tags.
+        #' @param jobScheduledStartTime Time when the job is scheduled to start.
+        #' @param jobPriority Priority of the job.
+        #' @param jobDryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+        #' @param data NextFlow run parameters.
+        run=fetchOpenCGA(object=OpencgaR, category="jobs", categoryId=NULL, subcategory=NULL, subcategoryId=NULL,
+                action="run", params=params, httpMethod="POST", as.queryParam=NULL, ...),
+
         #' @section Endpoint /{apiVersion}/jobs/search:
         #' Job search method.
         #' @param include Fields included in the response, whole JSON path must be provided.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
index 77c04be5053..d2fbb967c6b 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
@@ -27,6 +27,7 @@
 import org.opencb.opencga.core.models.job.JobAclUpdateParams;
 import org.opencb.opencga.core.models.job.JobCreateParams;
 import org.opencb.opencga.core.models.job.JobRetryParams;
+import org.opencb.opencga.core.models.job.JobRunParams;
 import org.opencb.opencga.core.models.job.JobTop;
 import org.opencb.opencga.core.models.job.JobUpdateParams;
 import org.opencb.opencga.core.response.RestResponse;
@@ -136,6 +137,28 @@ public RestResponse<Job> retry(JobRetryParams data, ObjectMap params) throws Cli
         return execute("jobs", null, null, null, "retry", params, POST, Job.class);
     }
 
+    /**
+     * Execute an analysis from a custom binary.
+     * @param data NextFlow run parameters.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       jobId: Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+     *       jobDescription: Job description.
+     *       jobDependsOn: Comma separated list of existing job IDs the job will depend on.
+     *       jobTags: Job tags.
+     *       jobScheduledStartTime: Time when the job is scheduled to start.
+     *       jobPriority: Priority of the job.
+     *       jobDryRun: Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all
+     *            parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Job> run(JobRunParams data, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.put("body", data);
+        return execute("jobs", null, null, null, "run", params, POST, Job.class);
+    }
+
     /**
      * Job search method.
      * @param params Map containing any of the following optional parameters.
diff --git a/opencga-client/src/main/javascript/Job.js b/opencga-client/src/main/javascript/Job.js
index f0ebb640147..fbbe2f66421 100644
--- a/opencga-client/src/main/javascript/Job.js
+++ b/opencga-client/src/main/javascript/Job.js
@@ -103,6 +103,25 @@ export default class Job extends OpenCGAParentClass {
         return this._post("jobs", null, null, null, "retry", data, params);
     }
 
+    /** Execute an analysis from a custom binary.
+    * @param {Object} data - NextFlow run parameters.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {String} [params.jobId] - Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not
+    *     provided.
+    * @param {String} [params.jobDescription] - Job description.
+    * @param {String} [params.jobDependsOn] - Comma separated list of existing job IDs the job will depend on.
+    * @param {String} [params.jobTags] - Job tags.
+    * @param {String} [params.jobScheduledStartTime] - Time when the job is scheduled to start.
+    * @param {String} [params.jobPriority] - Priority of the job.
+    * @param {Boolean} [params.jobDryRun] - Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will
+    *     validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    run(data, params) {
+        return this._post("jobs", null, null, null, "run", data, params);
+    }
+
     /** Job search method
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {String} [params.include] - Fields included in the response, whole JSON path must be provided.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
index c8425b16e6a..bc9fd3d34b0 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
@@ -114,6 +114,31 @@ def retry(self, data=None, **options):
 
         return self._post(category='jobs', resource='retry', data=data, **options)
 
+    def run(self, data=None, **options):
+        """
+        Execute an analysis from a custom binary.
+        PATH: /{apiVersion}/jobs/run
+
+        :param dict data: NextFlow run parameters. (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str job_id: Job ID. It must be a unique string within the
+            study. An ID will be autogenerated automatically if not provided.
+        :param str job_description: Job description.
+        :param str job_depends_on: Comma separated list of existing job IDs
+            the job will depend on.
+        :param str job_tags: Job tags.
+        :param str job_scheduled_start_time: Time when the job is scheduled to
+            start.
+        :param str job_priority: Priority of the job.
+        :param bool job_dry_run: Flag indicating that the job will be executed
+            in dry-run mode. In this mode, OpenCGA will validate that all
+            parameters and prerequisites are correctly set for successful
+            execution, but the job will not actually run.
+        """
+
+        return self._post(category='jobs', resource='run', data=data, **options)
+
     def search(self, **options):
         """
         Job search method.
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunDockerParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunDockerParams.java
new file mode 100644
index 00000000000..fb869fc0737
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunDockerParams.java
@@ -0,0 +1,56 @@
+package org.opencb.opencga.core.models.job;
+
+import org.opencb.opencga.core.tools.ToolParams;
+
+public class JobRunDockerParams extends ToolParams {
+
+    private String id;
+    private String tag;
+    private String token;
+
+    public JobRunDockerParams() {
+    }
+
+    public JobRunDockerParams(String id, String tag, String token) {
+        this.id = id;
+        this.tag = tag;
+        this.token = token;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("JobRunDockerParams{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", tag='").append(tag).append('\'');
+        sb.append(", token='").append(token).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public JobRunDockerParams setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getTag() {
+        return tag;
+    }
+
+    public JobRunDockerParams setTag(String tag) {
+        this.tag = tag;
+        return this;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public JobRunDockerParams setToken(String token) {
+        this.token = token;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunGitParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunGitParams.java
new file mode 100644
index 00000000000..056c85a181c
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunGitParams.java
@@ -0,0 +1,44 @@
+package org.opencb.opencga.core.models.job;
+
+import org.opencb.opencga.core.tools.ToolParams;
+
+public class JobRunGitParams extends ToolParams {
+
+    private String repository;
+    private String reference;
+
+    public JobRunGitParams() {
+    }
+
+    public JobRunGitParams(String repository, String reference) {
+        this.repository = repository;
+        this.reference = reference;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("JobRunGitParams{");
+        sb.append("repository='").append(repository).append('\'');
+        sb.append(", reference='").append(reference).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getRepository() {
+        return repository;
+    }
+
+    public JobRunGitParams setRepository(String repository) {
+        this.repository = repository;
+        return this;
+    }
+
+    public String getReference() {
+        return reference;
+    }
+
+    public JobRunGitParams setReference(String reference) {
+        this.reference = reference;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunParams.java
new file mode 100644
index 00000000000..c5ba91985d8
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobRunParams.java
@@ -0,0 +1,56 @@
+package org.opencb.opencga.core.models.job;
+
+import org.opencb.opencga.core.tools.ToolParams;
+
+public class JobRunParams extends ToolParams {
+
+    private String commandLine;
+    private JobRunDockerParams docker;
+    private JobRunGitParams git;
+
+    public JobRunParams() {
+    }
+
+    public JobRunParams(String commandLine, JobRunDockerParams docker, JobRunGitParams git) {
+        this.commandLine = commandLine;
+        this.docker = docker;
+        this.git = git;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("JobRunParams{");
+        sb.append("commandLine='").append(commandLine).append('\'');
+        sb.append(", docker=").append(docker);
+        sb.append(", git=").append(git);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getCommandLine() {
+        return commandLine;
+    }
+
+    public JobRunParams setCommandLine(String commandLine) {
+        this.commandLine = commandLine;
+        return this;
+    }
+
+    public JobRunDockerParams getDocker() {
+        return docker;
+    }
+
+    public JobRunParams setDocker(JobRunDockerParams docker) {
+        this.docker = docker;
+        return this;
+    }
+
+    public JobRunGitParams getGit() {
+        return git;
+    }
+
+    public JobRunParams setGit(JobRunGitParams git) {
+        this.git = git;
+        return this;
+    }
+}
diff --git a/opencga-core/src/test/java/org/opencb/opencga/core/config/ConfigurationTest.java b/opencga-core/src/test/java/org/opencb/opencga/core/config/ConfigurationTest.java
index 618797dc5c0..3bb947acac5 100644
--- a/opencga-core/src/test/java/org/opencb/opencga/core/config/ConfigurationTest.java
+++ b/opencga-core/src/test/java/org/opencb/opencga/core/config/ConfigurationTest.java
@@ -18,6 +18,10 @@
 
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
+import org.opencb.opencga.core.models.job.JobRunDockerParams;
+import org.opencb.opencga.core.models.job.JobRunParams;
+import org.opencb.opencga.core.models.variant.AnnotationVariantQueryParams;
+import org.opencb.opencga.core.models.variant.SampleQcAnalysisParams;
 import org.opencb.opencga.core.testclassification.duration.ShortTests;
 
 import java.io.IOException;
@@ -35,6 +39,14 @@ public class ConfigurationTest {
 
     @Test
     public void testDefault() throws IOException {
+        JobRunParams jobRunParams = new JobRunParams().setDocker(new JobRunDockerParams("repository", "tag", "token"));
+        Map<String, Object> params = jobRunParams.toParams();
+        System.out.println(params);
+
+        SampleQcAnalysisParams qcParams = new SampleQcAnalysisParams().setVsQuery(new AnnotationVariantQueryParams().setBiotype("biotype"));
+        Map<String, Object> params1 = qcParams.toParams();
+        System.out.println(params1);
+
         Configuration configuration = new Configuration();
 
         configuration.setLogLevel("INFO");
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
index 536d692099e..7f20f7ae8f7 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
@@ -20,6 +20,7 @@
 import org.apache.commons.lang3.StringUtils;
 import org.opencb.commons.datastore.core.Query;
 import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.opencga.analysis.binary.BinaryExecutor;
 import org.opencb.opencga.catalog.db.api.JobDBAdaptor;
 import org.opencb.opencga.catalog.managers.JobManager;
 import org.opencb.opencga.catalog.utils.Constants;
@@ -29,6 +30,7 @@
 import org.opencb.opencga.core.models.AclParams;
 import org.opencb.opencga.core.models.file.FileContent;
 import org.opencb.opencga.core.models.job.*;
+import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.*;
 
@@ -118,6 +120,24 @@ public Response kill(
         return run(() -> catalogManager.getJobManager().kill(study, jobId, token));
     }
 
+    @POST
+    @Path("/run")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @ApiOperation(value = BinaryExecutor.DESCRIPTION, response = Job.class)
+    public Response updateByPost(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String study,
+            @ApiParam(value = ParamConstants.JOB_ID_CREATION_DESCRIPTION) @QueryParam(ParamConstants.JOB_ID) String jobName,
+            @ApiParam(value = ParamConstants.JOB_DESCRIPTION_DESCRIPTION) @QueryParam(ParamConstants.JOB_DESCRIPTION) String jobDescription,
+            @ApiParam(value = ParamConstants.JOB_DEPENDS_ON_DESCRIPTION) @QueryParam(JOB_DEPENDS_ON) String dependsOn,
+            @ApiParam(value = ParamConstants.JOB_TAGS_DESCRIPTION) @QueryParam(ParamConstants.JOB_TAGS) String jobTags,
+            @ApiParam(value = ParamConstants.JOB_SCHEDULED_START_TIME_DESCRIPTION) @QueryParam(ParamConstants.JOB_SCHEDULED_START_TIME) String scheduledStartTime,
+            @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
+            @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
+            @ApiParam(value = NextFlowRunParams.DESCRIPTION, required = true) JobRunParams params) {
+        return submitJob(BinaryExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+    }
+
+
     @GET
     @Path("/{jobs}/info")
     @ApiOperation(value = "Get job information", response = Job.class)

From 2fca1158adfec22e1229c4605a1feccc5098ba70 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Wed, 18 Sep 2024 01:26:43 +0100
Subject: [PATCH 18/99] app: support Git repository when building new custom
 tools

---
 .../custom-tool-docker-build.py               | 29 +++++++++++++------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
index a4ef8a36c8b..66e291e0f8e 100755
--- a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
+++ b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
@@ -7,7 +7,8 @@
 ## Configure command-line options
 parser = argparse.ArgumentParser()
 parser.add_argument("action", help="Action to execute", choices=["dockerfile", "build", "push"], default="dockerfile")
-parser.add_argument("-t", "--custom-tool-dir", help="Path to the tool folder, this MUST contain a requirement.txt file")
+parser.add_argument("-t", "--custom-tool-dir", help="Path to the tool folder, this can contain a requirement.txt and/or install.r files", required=True)
+parser.add_argument("--install-r", help="Install R", action='store_true')
 parser.add_argument("--apt-get", help="List of apt-get packages to install")
 parser.add_argument("-o", "--organisation", help="Organisation of the Docker image", default="opencb")
 parser.add_argument("-n", "--name", help="Name of the docker image, e.g. my-tool")
@@ -76,10 +77,14 @@ def dockerfile():
 
     with open(custom_build_folder + "/Dockerfile", "w") as f:
         f.write("FROM ubuntu:24.04\n\n")
-        f.write("COPY . /app\n\n")
+        f.write("COPY . /opt/app\n\n")
 
         # Update Ubuntu and install base libraries
-        f.write("RUN apt update && apt -y upgrade && apt install -y python3 python3-pip r-base && \\ \n")
+        f.write("RUN apt update && apt -y upgrade && apt install -y python3 python3-pip && \\ \n")
+
+        # Install R
+        if args.install_r is True:
+            f.write("apt install -y r-base && \\ \n")
 
         # Install user's apt dependencies
         if args.apt_get is not None and not args.apt_get == "":
@@ -87,16 +92,16 @@ def dockerfile():
 
         # Install Python dependencies
         if os.path.isfile(custom_build_folder + "/requirements.txt"):
-            f.write("pip3 install -r /app/requirements.txt --break-system-packages && \\ \n")
+            f.write("pip3 install -r /opt/app/requirements.txt --break-system-packages && \\ \n")
 
         # Install R dependencies
-        if os.path.isfile(custom_build_folder + "/install.r"):
-            f.write("Rscript /app/install.r && \\ \n")
+        if args.install_r is True and os.path.isfile(custom_build_folder + "/install.r"):
+            f.write("Rscript /opt/app/install.r && \\ \n")
 
         f.write("rm -rf /var/lib/apt/lists/* \n\n")
 
-        f.write("USER opencga\n\n")
-        f.write("WORKDIR /app\n\n")
+        # f.write("USER opencga\n\n")
+        f.write("WORKDIR /opt/app\n\n")
         f.write("CMD bash\n")
 
 def build():
@@ -145,7 +150,13 @@ def push():
 
 # 1. Set build folder to default value if not set
 if args.custom_tool_dir is not None and not args.custom_tool_dir == "":
-    custom_build_folder = args.custom_tool_dir
+    if args.custom_tool_dir.startswith("git@"):
+        custom_build_folder = "/tmp/custom-tool"
+        os.system("rm -rf " + custom_build_folder)
+        os.system("git clone " + args.custom_tool_dir + " " + custom_build_folder)
+    else:
+        custom_build_folder = args.custom_tool_dir
+
     if not os.path.isdir(custom_build_folder):
         error("Custom tool folder does not exist: " + custom_build_folder)
 else:

From 126fbb14dc145762322e0e8c2015f1f8400f9c15 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 18 Sep 2024 11:12:31 +0200
Subject: [PATCH 19/99] core: add new fields to Workflow data model, #TASK-6445

---
 .../catalog/db/api/WorkflowDBAdaptor.java     |  2 +
 .../db/mongodb/WorkflowMongoDBAdaptor.java    |  3 +
 .../catalog/managers/WorkflowManager.java     | 16 +++--
 .../catalog/managers/WorkflowManagerTest.java |  6 ++
 .../src/main/R/R/Workflow-methods.R           | 22 +++++--
 .../client/rest/clients/WorkflowClient.java   | 20 ++++--
 .../src/main/javascript/Workflow.js           | 20 ++++--
 .../pyopencga/rest_clients/workflow_client.py | 34 ++++++++--
 .../opencga/core/api/FieldConstants.java      | 11 ++--
 .../opencga/core/api/ParamConstants.java      | 15 ++++-
 .../core/models/workflow/Workflow.java        | 64 ++++++++++++++-----
 .../models/workflow/WorkflowCreateParams.java | 51 +++++++++++++--
 .../core/models/workflow/WorkflowSystem.java  | 52 +++++++++++++++
 .../models/workflow/WorkflowUpdateParams.java | 47 +++++++++++++-
 .../opencga/server/rest/WorkflowWSServer.java | 12 +++-
 15 files changed, 314 insertions(+), 61 deletions(-)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowSystem.java

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
index 45e4e52af06..b235843f74f 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
@@ -26,9 +26,11 @@ enum QueryParams implements QueryParam {
         DESCRIPTION("description", TEXT, ""),
         DRAFT("draft", BOOLEAN, ""),
         TYPE("type", TEXT, ""),
+        TAGS("tags", TEXT_ARRAY, ""),
         COMMAND_LINE("commandLine", TEXT, ""),
         SCRIPTS("scripts", OBJECT, ""),
         VARIABLES("variables", OBJECT, ""),
+        INTERNAL_REGISTRATION_USER_ID("internal.registrationUserId", TEXT, ""),
         RELEASE("release", INTEGER, ""), //  Release where the sample was created
         SNAPSHOT("snapshot", INTEGER, ""), // Last version of sample at release = snapshot
         VERSION("version", INTEGER, ""), // Version of the sample
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index c3c9543c6ad..5194f488d18 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -558,8 +558,11 @@ protected Bson parseQuery(Query query, Document extraQuery, String user)
 //                        break;
                     case ID:
                     case UUID:
+                    case NAME:
+                    case TAGS:
                     case RELEASE:
                     case VERSION:
+                    case INTERNAL_REGISTRATION_USER_ID:
                     case TYPE:
                     case DRAFT:
                         addAutoOrQuery(queryParam.key(), queryParam.key(), queryCopy, queryParam.type(), andBsonList);
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 70c97d133db..69ec1f3a88f 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -550,13 +550,17 @@ private WorkflowDBAdaptor.QueryParams getFieldFilter(List<String> idList) throws
 
     private void validateNewWorkflow(Workflow workflow, String userId) throws CatalogParameterException {
         ParamUtils.checkIdentifier(workflow.getId(), ID.key());
-        if (Workflow.Type.values().length > 1) {
-            ParamUtils.checkObj(workflow.getType(), TYPE.key());
-        } else if (workflow.getType() == null) {
-            // TODO: Remove this condition in the future once we know we support more than one type.
-            // If there is only one valid type, we set it
-            workflow.setType(Workflow.Type.NEXTFLOW);
+        ParamUtils.checkObj(workflow.getType(), TYPE.key());
+        if (workflow.getManager() == null) {
+            workflow.setManager(new WorkflowSystem());
         }
+        if (workflow.getManager().getId() == null) {
+            workflow.getManager().setId(WorkflowSystem.SystemId.NEXTFLOW);
+        }
+        if (StringUtils.isEmpty(workflow.getManager().getVersion())) {
+            workflow.getManager().setVersion("24.04.4");
+        }
+        workflow.setTags(workflow.getTags() != null ? workflow.getTags() : Collections.emptyList());
         workflow.setScripts(workflow.getScripts() != null ? workflow.getScripts() : Collections.emptyList());
         boolean main = false;
         for (WorkflowScript script : workflow.getScripts()) {
diff --git a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
index 9625b012444..1ed25bd9d88 100644
--- a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
+++ b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
@@ -34,6 +34,7 @@ public void setUp() throws Exception {
     public void createWorkflowTest() throws CatalogException {
         Workflow workflow = new Workflow()
                 .setId("workflow")
+                .setType(Workflow.Type.OTHER)
                 .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
         OpenCGAResult<Workflow> result = workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
         assertEquals(1, result.getNumResults());
@@ -78,11 +79,13 @@ public void createWorkflowTest() throws CatalogException {
     public void workflowSearchTest() throws CatalogException {
         Workflow workflow = new Workflow()
                 .setId("workflow")
+                .setType(Workflow.Type.OTHER)
                 .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
         workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
 
         workflow = new Workflow()
                 .setId("workflow2")
+                .setType(Workflow.Type.OTHER)
                 .setDraft(true)
                 .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
         workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
@@ -107,11 +110,13 @@ public void workflowSearchTest() throws CatalogException {
     public void updateWorkflowTest() throws CatalogException {
         Workflow workflow = new Workflow()
                 .setId("workflow")
+                .setType(Workflow.Type.OTHER)
                 .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
         workflowManager.create(studyFqn, workflow, INCLUDE_RESULT, ownerToken);
 
         WorkflowUpdateParams updateParams = new WorkflowUpdateParams()
                 .setName("newName")
+                .setType(Workflow.Type.OTHER)
                 .setDraft(true)
                 .setCreationDate("20240101000000")
                 .setModificationDate("20240201000000")
@@ -131,6 +136,7 @@ public void updateWorkflowTest() throws CatalogException {
     public void deleteWorkflowTest() throws CatalogException {
         Workflow workflow = new Workflow()
                 .setId("workflow")
+                .setType(Workflow.Type.OTHER)
                 .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
         workflowManager.create(studyFqn, workflow, QueryOptions.empty(), ownerToken);
 
diff --git a/opencga-client/src/main/R/R/Workflow-methods.R b/opencga-client/src/main/R/R/Workflow-methods.R
index 3addb897cc1..1eb79d2dccb 100644
--- a/opencga-client/src/main/R/R/Workflow-methods.R
+++ b/opencga-client/src/main/R/R/Workflow-methods.R
@@ -20,9 +20,9 @@
 #' | endpointName | Endpoint WS | parameters accepted |
 #' | -- | :-- | --: |
 #' | create | /{apiVersion}/workflows/create | include, exclude, study, includeResult, body[*] |
-#' | distinct | /{apiVersion}/workflows/distinct | study, id, uuid, creationDate, modificationDate, acl, release, snapshot, deleted, field[*] |
+#' | distinct | /{apiVersion}/workflows/distinct | study, id, name, uuid, tags, draft, internal.registrationUserId, type, creationDate, modificationDate, acl, release, snapshot, deleted, field[*] |
 #' | run | /{apiVersion}/workflows/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
-#' | search | /{apiVersion}/workflows/search | include, exclude, limit, skip, count, study, id, uuid, creationDate, modificationDate, acl, release, snapshot, deleted |
+#' | search | /{apiVersion}/workflows/search | include, exclude, limit, skip, count, study, id, name, uuid, tags, draft, internal.registrationUserId, type, creationDate, modificationDate, acl, release, snapshot, deleted |
 #' | update | /{apiVersion}/workflows/{workflowId}/update | include, exclude, workflowId[*], study, includeResult, body |
 #' | acl | /{apiVersion}/workflows/{workflows}/acl | workflows[*], study, member, silent |
 #' | delete | /{apiVersion}/workflows/{workflows}/delete | study, workflows[*] |
@@ -50,8 +50,13 @@ setMethod("workflowClient", "OpencgaR", function(OpencgaR, workflowId, workflows
         #' @section Endpoint /{apiVersion}/workflows/distinct:
         #' Workflow distinct method.
         #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
-        #' @param id Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
-        #' @param uuid Comma separated list workflow UUIDs up to a maximum of 100.
+        #' @param id Comma separated list of workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+        #' @param name Comma separated list of workflow names up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+        #' @param uuid Comma separated list of workflow UUIDs up to a maximum of 100.
+        #' @param tags Comma separated list of tags.
+        #' @param draft Boolean field indicating whether the workflow is a draft or not.
+        #' @param internal.registrationUserId UserId that created the workflow.
+        #' @param type Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
         #' @param creationDate Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
         #' @param modificationDate Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
         #' @param acl Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example: acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS permissions. Only study owners or administrators can query by this field. .
@@ -84,8 +89,13 @@ setMethod("workflowClient", "OpencgaR", function(OpencgaR, workflowId, workflows
         #' @param skip Number of results to skip.
         #' @param count Get the total number of results matching the query. Deactivated by default.
         #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
-        #' @param id Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
-        #' @param uuid Comma separated list workflow UUIDs up to a maximum of 100.
+        #' @param id Comma separated list of workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+        #' @param name Comma separated list of workflow names up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+        #' @param uuid Comma separated list of workflow UUIDs up to a maximum of 100.
+        #' @param tags Comma separated list of tags.
+        #' @param draft Boolean field indicating whether the workflow is a draft or not.
+        #' @param internal.registrationUserId UserId that created the workflow.
+        #' @param type Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
         #' @param creationDate Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
         #' @param modificationDate Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
         #' @param acl Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example: acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS permissions. Only study owners or administrators can query by this field. .
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
index 5e5d5062edc..cd427ce16b4 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
@@ -72,9 +72,15 @@ public RestResponse<Workflow> create(WorkflowCreateParams data, ObjectMap params
      * @param field Comma separated list of fields for which to obtain the distinct values.
      * @param params Map containing any of the following optional parameters.
      *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
-     *       id: Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~',
+     *       id: Comma separated list of workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~',
      *            i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
-     *       uuid: Comma separated list workflow UUIDs up to a maximum of 100.
+     *       name: Comma separated list of workflow names up to a maximum of 100. Also admits basic regular expressions using the operator
+     *            '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+     *       uuid: Comma separated list of workflow UUIDs up to a maximum of 100.
+     *       tags: Comma separated list of tags.
+     *       draft: Boolean field indicating whether the workflow is a draft or not.
+     *       internal.registrationUserId: UserId that created the workflow.
+     *       type: Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
      *       creationDate: Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
      *       modificationDate: Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
      *       acl: Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example:
@@ -123,9 +129,15 @@ public RestResponse<Job> run(NextFlowRunParams data, ObjectMap params) throws Cl
      *       skip: Number of results to skip.
      *       count: Get the total number of results matching the query. Deactivated by default.
      *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
-     *       id: Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~',
+     *       id: Comma separated list of workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~',
      *            i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
-     *       uuid: Comma separated list workflow UUIDs up to a maximum of 100.
+     *       name: Comma separated list of workflow names up to a maximum of 100. Also admits basic regular expressions using the operator
+     *            '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+     *       uuid: Comma separated list of workflow UUIDs up to a maximum of 100.
+     *       tags: Comma separated list of tags.
+     *       draft: Boolean field indicating whether the workflow is a draft or not.
+     *       internal.registrationUserId: UserId that created the workflow.
+     *       type: Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
      *       creationDate: Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
      *       modificationDate: Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
      *       acl: Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example:
diff --git a/opencga-client/src/main/javascript/Workflow.js b/opencga-client/src/main/javascript/Workflow.js
index 29203f59fe6..fd949f3af44 100644
--- a/opencga-client/src/main/javascript/Workflow.js
+++ b/opencga-client/src/main/javascript/Workflow.js
@@ -52,9 +52,15 @@ export default class Workflow extends OpenCGAParentClass {
     * @param {String} field - Comma separated list of fields for which to obtain the distinct values.
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
-    * @param {String} [params.id] - Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using
+    * @param {String} [params.id] - Comma separated list of workflow IDs up to a maximum of 100. Also admits basic regular expressions using
     *     the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
-    * @param {String} [params.uuid] - Comma separated list workflow UUIDs up to a maximum of 100.
+    * @param {String} [params.name] - Comma separated list of workflow names up to a maximum of 100. Also admits basic regular expressions
+    *     using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+    * @param {String} [params.uuid] - Comma separated list of workflow UUIDs up to a maximum of 100.
+    * @param {String} [params.tags] - Comma separated list of tags.
+    * @param {Boolean} [params.draft] - Boolean field indicating whether the workflow is a draft or not.
+    * @param {String} [params.internal.registrationUserId] - UserId that created the workflow.
+    * @param {String} [params.type] - Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
     * @param {String} [params.creationDate] - Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
     * @param {String} [params.modificationDate] - Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
     * @param {String} [params.acl] - Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}.
@@ -97,9 +103,15 @@ export default class Workflow extends OpenCGAParentClass {
     * @param {Boolean} [params.count = "false"] - Get the total number of results matching the query. Deactivated by default. The default
     *     value is false.
     * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
-    * @param {String} [params.id] - Comma separated list workflow IDs up to a maximum of 100. Also admits basic regular expressions using
+    * @param {String} [params.id] - Comma separated list of workflow IDs up to a maximum of 100. Also admits basic regular expressions using
     *     the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
-    * @param {String} [params.uuid] - Comma separated list workflow UUIDs up to a maximum of 100.
+    * @param {String} [params.name] - Comma separated list of workflow names up to a maximum of 100. Also admits basic regular expressions
+    *     using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
+    * @param {String} [params.uuid] - Comma separated list of workflow UUIDs up to a maximum of 100.
+    * @param {String} [params.tags] - Comma separated list of tags.
+    * @param {Boolean} [params.draft] - Boolean field indicating whether the workflow is a draft or not.
+    * @param {String} [params.internal.registrationUserId] - UserId that created the workflow.
+    * @param {String} [params.type] - Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
     * @param {String} [params.creationDate] - Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
     * @param {String} [params.modificationDate] - Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
     * @param {String} [params.acl] - Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
index 1618e10883c..cc410139f15 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
@@ -46,12 +46,23 @@ def distinct(self, field, **options):
             the distinct values. (REQUIRED)
         :param str study: Study [[organization@]project:]study where study and
             project can be either the ID or UUID.
-        :param str id: Comma separated list workflow IDs up to a maximum of
+        :param str id: Comma separated list of workflow IDs up to a maximum of
             100. Also admits basic regular expressions using the operator '~',
             i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i'
             for case insensitive search.
-        :param str uuid: Comma separated list workflow UUIDs up to a maximum
-            of 100.
+        :param str name: Comma separated list of workflow names up to a
+            maximum of 100. Also admits basic regular expressions using the
+            operator '~', i.e. '~{perl-regex}' e.g. '~value' for case
+            sensitive, '~/value/i' for case insensitive search.
+        :param str uuid: Comma separated list of workflow UUIDs up to a
+            maximum of 100.
+        :param str tags: Comma separated list of tags.
+        :param bool draft: Boolean field indicating whether the workflow is a
+            draft or not.
+        :param str internal.registration_user_id: UserId that created the
+            workflow.
+        :param str type: Workflow type. Allowed types:
+            [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
         :param str creation_date: Creation date. Format: yyyyMMddHHmmss.
             Examples: >2018, 2017-2018, <201805.
         :param str modification_date: Modification date. Format:
@@ -110,12 +121,23 @@ def search(self, **options):
             Deactivated by default.
         :param str study: Study [[organization@]project:]study where study and
             project can be either the ID or UUID.
-        :param str id: Comma separated list workflow IDs up to a maximum of
+        :param str id: Comma separated list of workflow IDs up to a maximum of
             100. Also admits basic regular expressions using the operator '~',
             i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i'
             for case insensitive search.
-        :param str uuid: Comma separated list workflow UUIDs up to a maximum
-            of 100.
+        :param str name: Comma separated list of workflow names up to a
+            maximum of 100. Also admits basic regular expressions using the
+            operator '~', i.e. '~{perl-regex}' e.g. '~value' for case
+            sensitive, '~/value/i' for case insensitive search.
+        :param str uuid: Comma separated list of workflow UUIDs up to a
+            maximum of 100.
+        :param str tags: Comma separated list of tags.
+        :param bool draft: Boolean field indicating whether the workflow is a
+            draft or not.
+        :param str internal.registration_user_id: UserId that created the
+            workflow.
+        :param str type: Workflow type. Allowed types:
+            [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
         :param str creation_date: Creation date. Format: yyyyMMddHHmmss.
             Examples: >2018, 2017-2018, <201805.
         :param str modification_date: Modification date. Format:
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index d1a03fd4507..0e9d9b7f809 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -307,21 +307,20 @@ public class FieldConstants {
             + "VARIANT, ALIGNMENT, CLINICAL, EXPRESSION, RGA and FUNCTIONAL.";
 
     // Workflow
-    //Sample
     public static final String WORKFLOW_ID_DESCRIPTION = "Workflow ID.";
     public static final String WORKFLOW_NAME_DESCRIPTION = "Workflow name.";
     public static final String WORKFLOW_TYPE_DESCRIPTION = "Workflow type. Valid values: NEXTFLOW.";
+    public static final String WORKFLOW_MANAGER_DESCRIPTION = "Workflow system corresponding to the workflow.";
     public static final String WORKFLOW_DRAFT_DESCRIPTION = "Flag indicating whether the workflow is still a draft or not.";
     public static final String WORKFLOW_REPOSITORY_DESCRIPTION = "Workflow repository image to execute. If any, providing a list of"
             + " scripts will not be mandatory.";
     public static final String WORKFLOW_SCRIPTS_DESCRIPTION = "List of scripts used by the Workflow.";
+    public static final String WORKFLOW_TAGS_DESCRIPTION = "List of tags.";
     public static final String WORKFLOW_VARIABLES_DESCRIPTION = "List of variables accepted by the Workflow.";
     public static final String WORKFLOW_INTERNAL_DESCRIPTION = "Workflow internal information.";
-    public static final String WORKFLOW_SOMATIC_DESCRIPTION = "Describes if the sample is somatic or not .";
-    public static final String WORKFLOW_INDIVIDUAL_ID_DESCRIPTION = "Individual id of the sample.";
-    public static final String WORKFLOW_FILE_IDS_DESCRIPTION = "File ids of the sample.";
-    public static final String WORKFLOW_COHORT_IDS_DESCRIPTION = "Cohort ids of the sample.";
-    public static final String WORKFLOW_EXTERNAL_SOURCE_DESCRIPTION = "The external source from where the example was imported.";
+
+    public static final String WORKFLOW_SYSTEM_ID_DESCRIPTION = "Workflow system id. Valid values: NEXTFLOW.";
+    public static final String WORKFLOW_SYSTEM_VERSION_DESCRIPTION = "Workflow system version to use.";
 
     //FileInternal
     public static final String FILE_INTERNAL_STATUS_DESCRIPTION = "File status can have the values READY, DELETED, "
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
index 7040b87198f..9a52837423d 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
@@ -584,11 +584,20 @@ public class ParamConstants {
     public static final String WORKFLOW_VERSION_DESCRIPTION = "Comma separated list of workflow versions. 'all' to get all the workflow "
             + "versions. Not supported if multiple workflow ids are provided";
     public static final String WORKFLOWS_ID_PARAM = "id";
-    public static final String WORKFLOWS_ID_DESCRIPTION = "Comma separated list workflow IDs" + UP_TO_100 + REGEX_SUPPORT;
-    public static final String WORKFLOWS_UUID_DESCRIPTION = "Comma separated list workflow UUIDs" + UP_TO_100;
     public static final String WORKFLOWS_UUID_PARAM = "uuid";
-    public static final String WORKFLOWS_TYPE_DESCRIPTION = "Workflow type. Allowed types: [NEXTFLOW]";
+    public static final String WORKFLOWS_NAME_PARAM = "name";
     public static final String WORKFLOWS_TYPE_PARAM = "type";
+    public static final String WORKFLOWS_TAGS_PARAM = "tags";
+    public static final String WORKFLOWS_DRAFT_PARAM = "draft";
+    public static final String WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_PARAM = "internal.registrationUserId";
+    public static final String WORKFLOWS_ID_DESCRIPTION = "Comma separated list of workflow IDs" + UP_TO_100 + REGEX_SUPPORT;
+    public static final String WORKFLOWS_NAME_DESCRIPTION = "Comma separated list of workflow names" + UP_TO_100 + REGEX_SUPPORT;
+    public static final String WORKFLOWS_UUID_DESCRIPTION = "Comma separated list of workflow UUIDs" + UP_TO_100;
+    public static final String WORKFLOWS_TYPE_DESCRIPTION = "Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, "
+            + "RESEARCH or OTHER]";
+    public static final String WORKFLOWS_TAGS_DESCRIPTION = "Comma separated list of tags";
+    public static final String WORKFLOWS_DRAFT_DESCRIPTION = "Boolean field indicating whether the workflow is a draft or not.";
+    public static final String WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_DESCRIPTION = "UserId that created the workflow.";
     public static final String WORKFLOW_SCRIPTS_ACTION_DESCRIPTION = "Action to be performed if the array of scripts is being updated "
             + "[SET, ADD, REMOVE]";
     public static final String WORKFLOW_SCRIPTS_ACTION_PARAM = "scriptsAction";
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index e8bfbc11208..4e6398a3ab3 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -36,12 +36,18 @@ public class Workflow extends PrivateStudyUid {
     @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
     private Type type;
 
+    @DataField(id = "manager", description = FieldConstants.WORKFLOW_MANAGER_DESCRIPTION)
+    private WorkflowSystem manager;
+
     @DataField(id = "repository", description = FieldConstants.WORKFLOW_REPOSITORY_DESCRIPTION)
     private WorkflowRepository repository;
 
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
     private List<WorkflowScript> scripts;
 
+    @DataField(id = "tags", description = FieldConstants.WORKFLOW_TAGS_DESCRIPTION)
+    private List<String> tags;
+
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
     private List<Variable> variables;
 
@@ -58,22 +64,27 @@ public class Workflow extends PrivateStudyUid {
     private Map<String, Object> attributes;
 
     public enum Type {
-        NEXTFLOW
+        CLINICAL_INTERPRETATION,
+        SECONDARY_ANALYSIS,
+        RESEARCH,
+        OTHER
     }
 
     public Workflow() {
     }
 
-    public Workflow(String id, String name, String description, boolean draft, Type type, WorkflowRepository repository,
-                    List<WorkflowScript> scripts, List<Variable> variables, WorkflowInternal internal, String creationDate,
-                    String modificationDate, Map<String, Object> attributes) {
+    public Workflow(String id, String name, String description, boolean draft, Type type, WorkflowSystem manager,
+                    WorkflowRepository repository, List<WorkflowScript> scripts, List<String> tags, List<Variable> variables,
+                    WorkflowInternal internal, String creationDate, String modificationDate, Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
         this.description = description;
         this.draft = draft;
         this.type = type;
+        this.manager = manager;
         this.repository = repository;
         this.scripts = scripts;
+        this.tags = tags;
         this.variables = variables;
         this.internal = internal;
         this.creationDate = creationDate;
@@ -92,8 +103,10 @@ public String toString() {
         sb.append(", version=").append(version);
         sb.append(", release=").append(release);
         sb.append(", type=").append(type);
+        sb.append(", manager=").append(manager);
         sb.append(", repository=").append(repository);
         sb.append(", scripts=").append(scripts);
+        sb.append(", tags=").append(tags);
         sb.append(", variables=").append(variables);
         sb.append(", internal=").append(internal);
         sb.append(", creationDate='").append(creationDate).append('\'');
@@ -107,6 +120,7 @@ public String getId() {
         return id;
     }
 
+    @Override
     public Workflow setId(String id) {
         this.id = id;
         return this;
@@ -145,6 +159,15 @@ public Workflow setDescription(String description) {
         return this;
     }
 
+    public boolean isDraft() {
+        return draft;
+    }
+
+    public Workflow setDraft(boolean draft) {
+        this.draft = draft;
+        return this;
+    }
+
     public int getVersion() {
         return version;
     }
@@ -172,12 +195,12 @@ public Workflow setType(Type type) {
         return this;
     }
 
-    public boolean isDraft() {
-        return draft;
+    public WorkflowSystem getManager() {
+        return manager;
     }
 
-    public Workflow setDraft(boolean draft) {
-        this.draft = draft;
+    public Workflow setManager(WorkflowSystem manager) {
+        this.manager = manager;
         return this;
     }
 
@@ -190,21 +213,30 @@ public Workflow setRepository(WorkflowRepository repository) {
         return this;
     }
 
-    public List<Variable> getVariables() {
-        return variables;
+    public List<WorkflowScript> getScripts() {
+        return scripts;
     }
 
-    public Workflow setVariables(List<Variable> variables) {
-        this.variables = variables;
+    public Workflow setScripts(List<WorkflowScript> scripts) {
+        this.scripts = scripts;
         return this;
     }
 
-    public List<WorkflowScript> getScripts() {
-        return scripts;
+    public List<String> getTags() {
+        return tags;
     }
 
-    public Workflow setScripts(List<WorkflowScript> scripts) {
-        this.scripts = scripts;
+    public Workflow setTags(List<String> tags) {
+        this.tags = tags;
+        return this;
+    }
+
+    public List<Variable> getVariables() {
+        return variables;
+    }
+
+    public Workflow setVariables(List<Variable> variables) {
+        this.variables = variables;
         return this;
     }
 
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
index e6f2bcd0105..fd624e419f9 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -19,8 +19,14 @@ public class WorkflowCreateParams {
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
-//    @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
-//    private Workflow.Type type;
+    @DataField(id = "manager", description = FieldConstants.WORKFLOW_MANAGER_DESCRIPTION)
+    private WorkflowSystem manager;
+
+    @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
+    private Workflow.Type type;
+
+    @DataField(id = "tags", description = FieldConstants.WORKFLOW_TAGS_DESCRIPTION)
+    private List<String> tags;
 
     @DataField(id = "draft", description = FieldConstants.WORKFLOW_DRAFT_DESCRIPTION)
     private boolean draft;
@@ -46,12 +52,15 @@ public class WorkflowCreateParams {
     public WorkflowCreateParams() {
     }
 
-    public WorkflowCreateParams(String id, String name, String description, boolean draft, WorkflowRepository repository,
-                                List<Variable> variables, List<WorkflowScript> scripts, String creationDate, String modificationDate,
-                                Map<String, Object> attributes) {
+    public WorkflowCreateParams(String id, String name, String description, WorkflowSystem manager, Workflow.Type type, List<String> tags,
+                                boolean draft, WorkflowRepository repository, List<Variable> variables, List<WorkflowScript> scripts,
+                                String creationDate, String modificationDate, Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
         this.description = description;
+        this.manager = manager;
+        this.type = type;
+        this.tags = tags;
         this.draft = draft;
         this.repository = repository;
         this.variables = variables;
@@ -67,6 +76,9 @@ public String toString() {
         sb.append("id='").append(id).append('\'');
         sb.append(", name='").append(name).append('\'');
         sb.append(", description='").append(description).append('\'');
+        sb.append(", manager=").append(manager);
+        sb.append(", type=").append(type);
+        sb.append(", tags=").append(tags);
         sb.append(", draft=").append(draft);
         sb.append(", repository=").append(repository);
         sb.append(", variables=").append(variables);
@@ -79,7 +91,7 @@ public String toString() {
     }
 
     public Workflow toWorkflow() {
-        return new Workflow(id, name, description, draft, Workflow.Type.NEXTFLOW, repository, scripts, variables, new WorkflowInternal(),
+        return new Workflow(id, name, description, draft, type, manager, repository, scripts, tags, variables, new WorkflowInternal(),
                 creationDate, modificationDate, attributes);
     }
 
@@ -110,6 +122,33 @@ public WorkflowCreateParams setDescription(String description) {
         return this;
     }
 
+    public WorkflowSystem getManager() {
+        return manager;
+    }
+
+    public WorkflowCreateParams setManager(WorkflowSystem manager) {
+        this.manager = manager;
+        return this;
+    }
+
+    public Workflow.Type getType() {
+        return type;
+    }
+
+    public WorkflowCreateParams setType(Workflow.Type type) {
+        this.type = type;
+        return this;
+    }
+
+    public List<String> getTags() {
+        return tags;
+    }
+
+    public WorkflowCreateParams setTags(List<String> tags) {
+        this.tags = tags;
+        return this;
+    }
+
     public boolean isDraft() {
         return draft;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowSystem.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowSystem.java
new file mode 100644
index 00000000000..dc57eeba66b
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowSystem.java
@@ -0,0 +1,52 @@
+package org.opencb.opencga.core.models.workflow;
+
+import org.opencb.commons.annotations.DataField;
+import org.opencb.opencga.core.api.FieldConstants;
+
+public class WorkflowSystem {
+
+    @DataField(id = "id", description = FieldConstants.WORKFLOW_SYSTEM_ID_DESCRIPTION)
+    private SystemId id;
+
+    @DataField(id = "version", description = FieldConstants.WORKFLOW_SYSTEM_ID_DESCRIPTION)
+    private String version;
+
+    public enum SystemId {
+        NEXTFLOW
+    }
+
+    public WorkflowSystem() {
+    }
+
+    public WorkflowSystem(SystemId id, String version) {
+        this.id = id;
+        this.version = version;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowSystem{");
+        sb.append("id=").append(id);
+        sb.append(", version='").append(version).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public SystemId getId() {
+        return id;
+    }
+
+    public WorkflowSystem setId(SystemId id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public WorkflowSystem setVersion(String version) {
+        this.version = version;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
index 4f407348ef0..ba09ed1c219 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
@@ -15,6 +15,15 @@ public class WorkflowUpdateParams {
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
+    @DataField(id = "manager", description = FieldConstants.WORKFLOW_MANAGER_DESCRIPTION)
+    private WorkflowSystem manager;
+
+    @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
+    private Workflow.Type type;
+
+    @DataField(id = "tags", description = FieldConstants.WORKFLOW_TAGS_DESCRIPTION)
+    private List<String> tags;
+
     @DataField(id = "draft", description = FieldConstants.WORKFLOW_DRAFT_DESCRIPTION)
     private boolean draft;
 
@@ -39,10 +48,14 @@ public class WorkflowUpdateParams {
     public WorkflowUpdateParams() {
     }
 
-    public WorkflowUpdateParams(String name, String description, boolean draft, WorkflowRepository repository, List<WorkflowScript> scripts,
-                                List<Variable> variables, String creationDate, String modificationDate, Map<String, Object> attributes) {
+    public WorkflowUpdateParams(String name, String description, WorkflowSystem manager, Workflow.Type type, List<String> tags,
+                                boolean draft, WorkflowRepository repository, List<WorkflowScript> scripts, List<Variable> variables,
+                                String creationDate, String modificationDate, Map<String, Object> attributes) {
         this.name = name;
         this.description = description;
+        this.manager = manager;
+        this.type = type;
+        this.tags = tags;
         this.draft = draft;
         this.repository = repository;
         this.scripts = scripts;
@@ -57,6 +70,9 @@ public String toString() {
         final StringBuilder sb = new StringBuilder("WorkflowUpdateParams{");
         sb.append("name='").append(name).append('\'');
         sb.append(", description='").append(description).append('\'');
+        sb.append(", manager=").append(manager);
+        sb.append(", type=").append(type);
+        sb.append(", tags=").append(tags);
         sb.append(", draft=").append(draft);
         sb.append(", repository=").append(repository);
         sb.append(", scripts=").append(scripts);
@@ -86,6 +102,33 @@ public WorkflowUpdateParams setDescription(String description) {
         return this;
     }
 
+    public WorkflowSystem getManager() {
+        return manager;
+    }
+
+    public WorkflowUpdateParams setManager(WorkflowSystem manager) {
+        this.manager = manager;
+        return this;
+    }
+
+    public Workflow.Type getType() {
+        return type;
+    }
+
+    public WorkflowUpdateParams setType(Workflow.Type type) {
+        this.type = type;
+        return this;
+    }
+
+    public List<String> getTags() {
+        return tags;
+    }
+
+    public WorkflowUpdateParams setTags(List<String> tags) {
+        this.tags = tags;
+        return this;
+    }
+
     public boolean isDraft() {
         return draft;
     }
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
index 0c887f654ce..3e24d9b8378 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
@@ -116,8 +116,12 @@ public Response updateByPost(
     public Response search(
             @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
             @ApiParam(value = ParamConstants.WORKFLOWS_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_ID_PARAM) String id,
+            @ApiParam(value = ParamConstants.WORKFLOWS_NAME_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_NAME_PARAM) String name,
             @ApiParam(value = ParamConstants.WORKFLOWS_UUID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_UUID_PARAM) String uuid,
-//            @ApiParam(value = ParamConstants.WORKFLOWS_TYPE_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TYPE_PARAM) String type,
+            @ApiParam(value = ParamConstants.WORKFLOWS_TAGS_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TAGS_PARAM) String tags,
+            @ApiParam(value = ParamConstants.WORKFLOWS_DRAFT_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_DRAFT_PARAM) Boolean draft,
+            @ApiParam(value = ParamConstants.WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_PARAM) String userId,
+            @ApiParam(value = ParamConstants.WORKFLOWS_TYPE_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TYPE_PARAM) String type,
             @ApiParam(value = ParamConstants.CREATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.CREATION_DATE_PARAM) String creationDate,
             @ApiParam(value = ParamConstants.MODIFICATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.MODIFICATION_DATE_PARAM) String modificationDate,
             @ApiParam(value = ParamConstants.ACL_DESCRIPTION) @QueryParam(ParamConstants.ACL_PARAM) String acl,
@@ -139,8 +143,12 @@ public Response search(
     public Response distinct(
             @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
             @ApiParam(value = ParamConstants.WORKFLOWS_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_ID_PARAM) String id,
+            @ApiParam(value = ParamConstants.WORKFLOWS_NAME_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_NAME_PARAM) String name,
             @ApiParam(value = ParamConstants.WORKFLOWS_UUID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_UUID_PARAM) String uuid,
-//            @ApiParam(value = ParamConstants.WORKFLOWS_TYPE_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TYPE_PARAM) String type,
+            @ApiParam(value = ParamConstants.WORKFLOWS_TAGS_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TAGS_PARAM) String tags,
+            @ApiParam(value = ParamConstants.WORKFLOWS_DRAFT_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_DRAFT_PARAM) Boolean draft,
+            @ApiParam(value = ParamConstants.WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_PARAM) String userId,
+            @ApiParam(value = ParamConstants.WORKFLOWS_TYPE_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TYPE_PARAM) String type,
             @ApiParam(value = ParamConstants.CREATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.CREATION_DATE_PARAM) String creationDate,
             @ApiParam(value = ParamConstants.MODIFICATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.MODIFICATION_DATE_PARAM) String modificationDate,
             @ApiParam(value = ParamConstants.ACL_DESCRIPTION) @QueryParam(ParamConstants.ACL_PARAM) String acl,

From 73541880d2a8318544c4ef39f33c33f7cd8ae80c Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 18 Sep 2024 13:09:42 +0200
Subject: [PATCH 20/99] server: add new WS to set acls to workflows, #TASK-6445

---
 .../db/mongodb/AuthorizationMongoDBUtils.java |  2 +
 .../catalog/managers/WorkflowManager.java     | 28 +++++-------
 .../catalog/managers/WorkflowManagerTest.java | 25 +++++++++--
 .../workflow/WorkflowAclUpdateParams.java     | 44 +++++++++++++++++++
 .../opencga/server/rest/WorkflowWSServer.java | 36 +++++++--------
 5 files changed, 95 insertions(+), 40 deletions(-)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowAclUpdateParams.java

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/AuthorizationMongoDBUtils.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/AuthorizationMongoDBUtils.java
index fb8a3952f50..2218056e813 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/AuthorizationMongoDBUtils.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/AuthorizationMongoDBUtils.java
@@ -191,6 +191,8 @@ private static int getPermissionType(Enums.Resource resource) throws CatalogPara
                 return StudyPermissions.FAMILY;
             case CLINICAL_ANALYSIS:
                 return StudyPermissions.CLINICAL_ANALYSIS;
+            case WORKFLOW:
+                return StudyPermissions.WORKFLOW;
             default:
                 throw new CatalogParameterException("Unexpected resource '" + resource + "'.");
         }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 69ec1f3a88f..13462d52f44 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -27,7 +27,6 @@
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Configuration;
 import org.opencb.opencga.core.models.AclEntryList;
-import org.opencb.opencga.core.models.AclParams;
 import org.opencb.opencga.core.models.JwtPayload;
 import org.opencb.opencga.core.models.audit.AuditRecord;
 import org.opencb.opencga.core.models.common.Enums;
@@ -686,9 +685,8 @@ public OpenCGAResult<AclEntryList<WorkflowPermissions>> getAcls(String studyStr,
         return workflowAcls;
     }
 
-    public OpenCGAResult<AclEntryList<WorkflowPermissions>> updateAcl(String studyStr, List<String> workflowStringList, String memberList,
-                                                                      AclParams aclParams, ParamUtils.AclAction action, String token)
-            throws CatalogException {
+    public OpenCGAResult<AclEntryList<WorkflowPermissions>> updateAcl(String studyStr, String memberList, WorkflowAclUpdateParams params,
+                                                                      ParamUtils.AclAction action, String token) throws CatalogException {
         JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
         CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
         String organizationId = studyFqn.getOrganizationId();
@@ -697,32 +695,30 @@ public OpenCGAResult<AclEntryList<WorkflowPermissions>> updateAcl(String studySt
 
         ObjectMap auditParams = new ObjectMap()
                 .append("studyId", studyStr)
-                .append("workflowStringList", workflowStringList)
                 .append("memberList", memberList)
-                .append("aclParams", aclParams)
+                .append("params", params)
                 .append("action", action)
                 .append("token", token);
         String operationId = UuidUtils.generateOpenCgaUuid(UuidUtils.Entity.AUDIT);
 
         List<String> members;
         List<Workflow> workflowList;
-        List<String> permissions = Collections.emptyList();
         try {
             auditManager.initAuditBatch(operationId);
 
-            if (CollectionUtils.isEmpty(workflowStringList)) {
+            ParamUtils.checkObj(params, "WorkflowAclUpdateParams");
+
+            if (CollectionUtils.isEmpty(params.getWorkflowIds())) {
                 throw new CatalogException("Update ACL: No workflows provided to be updated.");
             }
             if (action == null) {
                 throw new CatalogException("Invalid action found. Please choose a valid action to be performed.");
             }
-
-            if (StringUtils.isNotEmpty(aclParams.getPermissions())) {
-                permissions = Arrays.asList(aclParams.getPermissions().trim().replaceAll("\\s", "").split(","));
-                checkPermissions(permissions, WorkflowPermissions::valueOf);
+            if (CollectionUtils.isNotEmpty(params.getPermissions())) {
+                checkPermissions(params.getPermissions(), WorkflowPermissions::valueOf);
             }
 
-            workflowList = internalGet(organizationId, study.getUid(), workflowStringList, INCLUDE_WORKFLOW_IDS, userId, false)
+            workflowList = internalGet(organizationId, study.getUid(), params.getWorkflowIds(), INCLUDE_WORKFLOW_IDS, userId, false)
                     .getResults();
             authorizationManager.checkCanAssignOrSeePermissions(organizationId, study.getUid(), userId);
 
@@ -735,8 +731,8 @@ public OpenCGAResult<AclEntryList<WorkflowPermissions>> updateAcl(String studySt
             checkMembers(organizationId, study.getUid(), members);
             authorizationManager.checkNotAssigningPermissionsToAdminsGroup(members);
         } catch (CatalogException e) {
-            if (workflowStringList != null) {
-                for (String workflowId : workflowStringList) {
+            if (CollectionUtils.isNotEmpty(params.getWorkflowIds())) {
+                for (String workflowId : params.getWorkflowIds()) {
                     auditManager.audit(organizationId, operationId, userId, Enums.Action.UPDATE_ACLS, Enums.Resource.WORKFLOW, workflowId,
                             "", study.getId(), study.getUuid(), auditParams,
                             new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()), new ObjectMap());
@@ -758,7 +754,7 @@ public OpenCGAResult<AclEntryList<WorkflowPermissions>> updateAcl(String studySt
             List<Long> workflowUids = batchWorkflowList.stream().map(Workflow::getUid).collect(Collectors.toList());
             List<String> workflowIds = batchWorkflowList.stream().map(Workflow::getId).collect(Collectors.toList());
             List<AuthorizationManager.CatalogAclParams> aclParamsList = new ArrayList<>();
-            AuthorizationManager.CatalogAclParams.addToList(workflowUids, permissions, Enums.Resource.WORKFLOW, aclParamsList);
+            AuthorizationManager.CatalogAclParams.addToList(workflowUids, params.getPermissions(), Enums.Resource.WORKFLOW, aclParamsList);
 
             try {
                 switch (action) {
diff --git a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
index 1ed25bd9d88..e88e3158d9a 100644
--- a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
+++ b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
@@ -6,11 +6,10 @@
 import org.opencb.commons.datastore.core.Query;
 import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
+import org.opencb.opencga.catalog.exceptions.CatalogAuthorizationException;
 import org.opencb.opencga.catalog.exceptions.CatalogException;
-import org.opencb.opencga.core.models.workflow.Workflow;
-import org.opencb.opencga.core.models.workflow.WorkflowRepository;
-import org.opencb.opencga.core.models.workflow.WorkflowScript;
-import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
+import org.opencb.opencga.catalog.utils.ParamUtils;
+import org.opencb.opencga.core.models.workflow.*;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.testclassification.duration.MediumTests;
 
@@ -148,4 +147,22 @@ public void deleteWorkflowTest() throws CatalogException {
         assertTrue(exception.getMessage().contains("not found"));
     }
 
+    @Test
+    public void updateWorkflowAclTest() throws CatalogException {
+        Workflow workflow = new Workflow()
+                .setId("workflow")
+                .setType(Workflow.Type.OTHER)
+                .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", "echo 'Hello world!'", true)));
+        workflowManager.create(studyFqn, workflow, QueryOptions.empty(), ownerToken);
+
+        CatalogAuthorizationException catalogAuthorizationException = assertThrows(CatalogAuthorizationException.class,
+                () -> workflowManager.get(studyFqn, workflow.getId(), QueryOptions.empty(), noAccessToken1));
+        assertTrue(catalogAuthorizationException.getMessage().contains("denied"));
+
+        workflowManager.updateAcl(studyFqn, noAccessUserId1, new WorkflowAclUpdateParams(Collections.singletonList(workflow.getId()), Collections.singletonList("VIEW")),
+                ParamUtils.AclAction.ADD, ownerToken);
+        OpenCGAResult<Workflow> result = workflowManager.get(studyFqn, workflow.getId(), QueryOptions.empty(), noAccessToken1);
+        assertEquals(1, result.getNumResults());
+    }
+
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowAclUpdateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowAclUpdateParams.java
new file mode 100644
index 00000000000..7f6cea398e2
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowAclUpdateParams.java
@@ -0,0 +1,44 @@
+package org.opencb.opencga.core.models.workflow;
+
+import java.util.List;
+
+public class WorkflowAclUpdateParams {
+
+    private List<String> workflowIds;
+    private List<String> permissions;
+
+    public WorkflowAclUpdateParams() {
+    }
+
+    public WorkflowAclUpdateParams(List<String> workflowIds, List<String> permissions) {
+        this.workflowIds = workflowIds;
+        this.permissions = permissions;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowAclUpdateParams{");
+        sb.append("workflowIds=").append(workflowIds);
+        sb.append(", permissions=").append(permissions);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public List<String> getWorkflowIds() {
+        return workflowIds;
+    }
+
+    public WorkflowAclUpdateParams setWorkflowIds(List<String> workflowIds) {
+        this.workflowIds = workflowIds;
+        return this;
+    }
+
+    public List<String> getPermissions() {
+        return permissions;
+    }
+
+    public WorkflowAclUpdateParams setPermissions(List<String> permissions) {
+        this.permissions = permissions;
+        return this;
+    }
+}
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
index 3e24d9b8378..99d86ea8d58 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
@@ -6,6 +6,7 @@
 import org.opencb.opencga.analysis.workflow.NextFlowExecutor;
 import org.opencb.opencga.catalog.managers.WorkflowManager;
 import org.opencb.opencga.catalog.utils.Constants;
+import org.opencb.opencga.catalog.utils.ParamUtils;
 import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.exceptions.VersionException;
 import org.opencb.opencga.core.models.job.Job;
@@ -221,26 +222,21 @@ public Response getAcls(@ApiParam(value = ParamConstants.WORKFLOWS_DESCRIPTION,
         }
     }
 
-//    @POST
-//    @Path("/acl/{members}/update")
-//    @ApiOperation(value = "Update the set of permissions granted for the member", response = WorkflowAclEntryList.class)
-//    public Response updateAcl(
-//            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
-//            @ApiParam(value = "Comma separated list of user or group ids", required = true) @PathParam("members") String memberId,
-//            @ApiParam(value = ParamConstants.ACL_ACTION_DESCRIPTION, required = true, defaultValue = "ADD") @QueryParam(ParamConstants.ACL_ACTION_PARAM) ParamUtils.AclAction action,
-//            @ApiParam(value = "JSON containing the parameters to update the permissions. If propagate flag is set to true, it will "
-//                    + "propagate the permissions defined to the individuals that are associated to the matching workflows", required = true)
-//            SampleAclUpdateParams params) {
-//        try {
-//            params = ObjectUtils.defaultIfNull(params, new SampleAclUpdateParams());
-//            SampleAclParams sampleAclParams = new SampleAclParams(
-//                    params.getIndividual(), params.getFamily(), params.getFile(), params.getCohort(), params.getPermissions());
-//            List<String> idList = StringUtils.isEmpty(params.getSample()) ? Collections.emptyList() : getIdList(params.getSample(), false);
-//            return createOkResponse(sampleManager.updateAcl(studyStr, idList, memberId, sampleAclParams, action, token));
-//        } catch (Exception e) {
-//            return createErrorResponse(e);
-//        }
-//    }
+    @POST
+    @Path("/acl/{members}/update")
+    @ApiOperation(value = "Update the set of permissions granted for the member", response = WorkflowAclEntryList.class)
+    public Response updateAcl(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
+            @ApiParam(value = "Comma separated list of user or group ids", required = true) @PathParam("members") String memberIds,
+            @ApiParam(value = ParamConstants.ACL_ACTION_DESCRIPTION, required = true, defaultValue = "ADD")
+                @QueryParam(ParamConstants.ACL_ACTION_PARAM) ParamUtils.AclAction action,
+            @ApiParam(value = "JSON containing the parameters to update the permissions.", required = true) WorkflowAclUpdateParams params) {
+        try {
+            return createOkResponse(workflowManager.updateAcl(studyStr, memberIds, params, action, token));
+        } catch (Exception e) {
+            return createErrorResponse(e);
+        }
+    }
 
 
 }

From 7c2f6db2b7329f7b6d3f6262349c99b8a670004f Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 18 Sep 2024 15:40:29 +0200
Subject: [PATCH 21/99] analysis: add tags/attributes to Job, #TASK-6445

---
 .../opencga/analysis/binary/BinaryExecutor.java  | 10 ++++++++++
 .../analysis/tools/OpenCgaToolScopeStudy.java    | 12 ++++++++++++
 .../analysis/workflow/NextFlowExecutor.java      | 16 +++++++++++++++-
 3 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
index a92a270b15f..3ef8fd442cc 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
@@ -2,6 +2,7 @@
 
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
+import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.utils.DockerUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
 import org.opencb.opencga.analysis.utils.InputFileUtils;
@@ -58,6 +59,15 @@ protected void check() throws Exception {
             this.dockerImage += ":" + runParams.getDocker().getTag();
         }
 
+        // Update job tags and attributes
+        ObjectMap attributes = new ObjectMap()
+                .append("DOCKER_ID", runParams.getDocker().getId())
+                .append("DOCKER_TAG", runParams.getDocker().getTag());
+        List<String> tags = new LinkedList<>();
+        tags.add(ID);
+        tags.add(this.dockerImage);
+        updateJobInformation(tags, attributes);
+
         // Build input bindings
         this.inputBindings = new LinkedList<>();
         InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
index 016ffa32058..39c4282109d 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
@@ -16,9 +16,14 @@
 
 package org.opencb.opencga.analysis.tools;
 
+import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.managers.StudyManager;
 import org.opencb.opencga.core.api.ParamConstants;
+import org.opencb.opencga.core.models.job.JobUpdateParams;
+
+import java.util.List;
 
 public abstract class OpenCgaToolScopeStudy extends OpenCgaTool {
 
@@ -50,4 +55,11 @@ protected final String getStudyFqn() throws CatalogException {
                 getToken()).first().getFqn();
     }
 
+    protected void updateJobInformation(List<String> tags, ObjectMap attributes) throws CatalogException {
+        JobUpdateParams updateParams = new JobUpdateParams()
+                .setTags(tags)
+                .setAttributes(attributes);
+        catalogManager.getJobManager().update(getStudyFqn(), getJobId(), updateParams, QueryOptions.empty(), token);
+    }
+
 }
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 494c2e08aff..157acd262aa 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -41,7 +41,7 @@
 @Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.WORKFLOW, description = NextFlowExecutor.DESCRIPTION)
 public class NextFlowExecutor extends OpenCgaToolScopeStudy {
 
-    public final static String ID = "nextflow";
+    public final static String ID = "workflow";
     public static final String DESCRIPTION = "Execute a Nextflow analysis.";
 
     @ToolParams
@@ -75,6 +75,20 @@ protected void check() throws Exception {
             throw new ToolException("Workflow '" + nextflowParams.getId() + "' is null");
         }
 
+        // Update job tags and attributes
+        ObjectMap attributes = new ObjectMap()
+                .append("WORKFLOW_ID", workflow.getManager().getId())
+                .append("WORKFLOW_VERSION", workflow.getManager().getVersion());
+        List<String> tags = new LinkedList<>();
+        tags.add(ID);
+        tags.add(workflow.getManager().getId().name());
+        tags.add(workflow.getManager().getId() + ":" + workflow.getManager().getVersion());
+        tags.add(workflow.getId());
+        if (CollectionUtils.isNotEmpty(workflow.getTags())) {
+            tags.addAll(workflow.getTags());
+        }
+        updateJobInformation(tags, attributes);
+
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
             this.inputFileUris = new LinkedList<>();
             InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);

From c91061a62faf7427b28228515f51bd5712e51385 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Thu, 19 Sep 2024 02:13:24 +0100
Subject: [PATCH 22/99] Update clients

---
 opencga-client/src/main/R/R/AllGenerics.R     |  2 +-
 .../src/main/R/R/Workflow-methods.R           | 13 ++++++++++++-
 .../client/rest/clients/WorkflowClient.java   | 19 +++++++++++++++++++
 .../src/main/javascript/Workflow.js           | 14 +++++++++++++-
 .../pyopencga/rest_clients/workflow_client.py | 18 ++++++++++++++++++
 5 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/opencga-client/src/main/R/R/AllGenerics.R b/opencga-client/src/main/R/R/AllGenerics.R
index 43e9f2da447..d6e8959a00c 100644
--- a/opencga-client/src/main/R/R/AllGenerics.R
+++ b/opencga-client/src/main/R/R/AllGenerics.R
@@ -30,7 +30,7 @@ setGeneric("jobClient", function(OpencgaR, job, jobs, members, endpointName, par
 
 # ##############################################################################
 ## WorkflowClient
-setGeneric("workflowClient", function(OpencgaR, workflowId, workflows, endpointName, params=NULL, ...)
+setGeneric("workflowClient", function(OpencgaR, members, workflowId, workflows, endpointName, params=NULL, ...)
     standardGeneric("workflowClient"))
 
 # ##############################################################################
diff --git a/opencga-client/src/main/R/R/Workflow-methods.R b/opencga-client/src/main/R/R/Workflow-methods.R
index 1eb79d2dccb..84e2d99f05e 100644
--- a/opencga-client/src/main/R/R/Workflow-methods.R
+++ b/opencga-client/src/main/R/R/Workflow-methods.R
@@ -19,6 +19,7 @@
 #'
 #' | endpointName | Endpoint WS | parameters accepted |
 #' | -- | :-- | --: |
+#' | updateAcl | /{apiVersion}/workflows/acl/{members}/update | study, members[*], action[*], body[*] |
 #' | create | /{apiVersion}/workflows/create | include, exclude, study, includeResult, body[*] |
 #' | distinct | /{apiVersion}/workflows/distinct | study, id, name, uuid, tags, draft, internal.registrationUserId, type, creationDate, modificationDate, acl, release, snapshot, deleted, field[*] |
 #' | run | /{apiVersion}/workflows/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
@@ -34,9 +35,19 @@
 #' [*]: Required parameter
 #' @export
 
-setMethod("workflowClient", "OpencgaR", function(OpencgaR, workflowId, workflows, endpointName, params=NULL, ...) {
+setMethod("workflowClient", "OpencgaR", function(OpencgaR, members, workflowId, workflows, endpointName, params=NULL, ...) {
     switch(endpointName,
 
+        #' @section Endpoint /{apiVersion}/workflows/acl/{members}/update:
+        #' Update the set of permissions granted for the member.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param members Comma separated list of user or group ids.
+        #' @param action Action to be performed [ADD, SET, REMOVE or RESET]. Allowed values: ['SET ADD REMOVE RESET']
+        #' @param data JSON containing the parameters to update the permissions.
+        updateAcl=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory="acl",
+                subcategoryId=members, action="update", params=params, httpMethod="POST", as.queryParam=c("action"),
+                ...),
+
         #' @section Endpoint /{apiVersion}/workflows/create:
         #' Create a workflow.
         #' @param include Fields included in the response, whole JSON path must be provided.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
index cd427ce16b4..652f15f93e1 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
@@ -25,6 +25,7 @@
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
+import org.opencb.opencga.core.models.workflow.WorkflowAclUpdateParams;
 import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
 import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
 import org.opencb.opencga.core.response.RestResponse;
@@ -50,6 +51,24 @@ public WorkflowClient(String token, ClientConfiguration configuration) {
         super(token, configuration);
     }
 
+    /**
+     * Update the set of permissions granted for the member.
+     * @param members Comma separated list of user or group ids.
+     * @param action Action to be performed [ADD, SET, REMOVE or RESET].
+     * @param data JSON containing the parameters to update the permissions.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<WorkflowAclEntryList> updateAcl(String members, String action, WorkflowAclUpdateParams data, ObjectMap params)
+            throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.putIfNotNull("action", action);
+        params.put("body", data);
+        return execute("workflows", null, "acl", members, "update", params, POST, WorkflowAclEntryList.class);
+    }
+
     /**
      * Create a workflow.
      * @param data JSON containing workflow information.
diff --git a/opencga-client/src/main/javascript/Workflow.js b/opencga-client/src/main/javascript/Workflow.js
index fd949f3af44..217d12f0826 100644
--- a/opencga-client/src/main/javascript/Workflow.js
+++ b/opencga-client/src/main/javascript/Workflow.js
@@ -34,6 +34,18 @@ export default class Workflow extends OpenCGAParentClass {
         super(config);
     }
 
+    /** Update the set of permissions granted for the member
+    * @param {String} members - Comma separated list of user or group ids.
+    * @param {Object} data - JSON containing the parameters to update the permissions.
+    * @param {"SET ADD REMOVE RESET"} action = "ADD" - Action to be performed [ADD, SET, REMOVE or RESET]. The default value is ADD.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    updateAcl(members, action, data, params) {
+        return this._post("workflows", null, "acl", members, "update", data, {action, ...params});
+    }
+
     /** Create a workflow
     * @param {Object} data - JSON containing workflow information.
     * @param {Object} [params] - The Object containing the following optional parameters:
@@ -47,7 +59,7 @@ export default class Workflow extends OpenCGAParentClass {
     create(data, params) {
         return this._post("workflows", null, null, null, "create", data, params);
     }
-
+#
     /** Workflow distinct method
     * @param {String} field - Comma separated list of fields for which to obtain the distinct values.
     * @param {Object} [params] - The Object containing the following optional parameters:
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
index cc410139f15..fdf242702e7 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
@@ -19,6 +19,24 @@ class Workflow(_ParentRestClient):
     def __init__(self, configuration, token=None, login_handler=None, *args, **kwargs):
         super(Workflow, self).__init__(configuration, token, login_handler, *args, **kwargs)
 
+    def update_acl(self, members, action, data=None, **options):
+        """
+        Update the set of permissions granted for the member.
+        PATH: /{apiVersion}/workflows/acl/{members}/update
+
+        :param dict data: JSON containing the parameters to update the
+            permissions. (REQUIRED)
+        :param str action: Action to be performed [ADD, SET, REMOVE or RESET].
+            Allowed values: ['SET ADD REMOVE RESET'] (REQUIRED)
+        :param str members: Comma separated list of user or group ids.
+            (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        """
+
+        options['action'] = action
+        return self._post(category='workflows', resource='update', subcategory='acl', second_query_id=members, data=data, **options)
+
     def create(self, data=None, **options):
         """
         Create a workflow.

From da72511e8233a34b6a4abdfeb255de60ae74d542 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 19 Sep 2024 14:10:04 +0200
Subject: [PATCH 23/99] core: improve nextflow executor, #TASK-6445

---
 .../analysis/utils/InputFileUtils.java        |  5 +-
 .../analysis/workflow/NextFlowExecutor.java   | 82 +++++++++----------
 .../src/main/resources/nextflow.config        |  2 +-
 .../analysis/tools/WorkflowExecutorTest.java  |  7 +-
 .../resources/nextflow/pipeline_cat_file.nf   |  2 +-
 .../catalog/managers/WorkflowManager.java     |  2 +-
 opencga-client/src/main/R/R/AllGenerics.R     |  2 +-
 .../src/main/R/R/Workflow-methods.R           | 13 ++-
 .../client/rest/clients/WorkflowClient.java   | 19 +++++
 .../src/main/javascript/Workflow.js           | 12 +++
 .../pyopencga/rest_clients/workflow_client.py | 18 ++++
 .../opencga/core/common/UserProcessUtils.java | 41 ++++++++++
 .../core/models/workflow/WorkflowScript.java  | 18 ++--
 13 files changed, 161 insertions(+), 62 deletions(-)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/common/UserProcessUtils.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java
index 9cdbf4b9efc..e1aafcab329 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java
@@ -15,7 +15,7 @@ public class InputFileUtils {
 
     private final CatalogManager catalogManager;
 
-    private static final Pattern OPERATION_PATTERN = Pattern.compile("^(?i)(ocga://|opencga://)(.+)$");
+    private static final Pattern OPERATION_PATTERN = Pattern.compile("^(?i)(ocga://|opencga://|file://)(.+)$");
 
     private final static Logger logger = LoggerFactory.getLogger(InputFileUtils.class);
 
@@ -31,7 +31,8 @@ public File getOpenCGAFile(String study, String file, String token) throws Catal
         Matcher matcher = OPERATION_PATTERN.matcher(file);
 
         if (!matcher.find()) {
-            throw new CatalogException("Invalid OpenCGA file format. Accepted format is 'ocga://<path>' or 'opencga://<path>'");
+            throw new CatalogException("Invalid OpenCGA file format. Accepted format is 'ocga://<path>', 'opencga://<path>' or"
+                    + " 'file://<path>'.");
         }
 
         String filePath = matcher.group(2);
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 157acd262aa..e25efffa376 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -8,10 +8,12 @@
 import org.apache.commons.lang3.time.StopWatch;
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.commons.utils.DockerUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
 import org.opencb.opencga.analysis.utils.InputFileUtils;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
+import org.opencb.opencga.core.common.UserProcessUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.file.File;
@@ -26,13 +28,11 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
 import java.io.UncheckedIOException;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.*;
@@ -51,10 +51,15 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
     private String cliParams;
     // Build list of inputfiles in case we need to specifically mount them in read only mode
     private List<String> inputFileUris;
+    // Build list of inputfiles in case we need to specifically mount them in read only mode
+    List<AbstractMap.SimpleEntry<String, String>> inputBindings;
 
     private Thread thread;
     private final int monitorThreadPeriod = 5000;
 
+    private final Path inputDir = Paths.get("/data/input");
+    private final String outputDir = "/data/output";
+
     private final static Logger logger = LoggerFactory.getLogger(NextFlowExecutor.class);
 
     @Override
@@ -87,8 +92,9 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
-        updateJobInformation(tags, attributes);
+//        updateJobInformation(tags, attributes);
 
+        this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
             this.inputFileUris = new LinkedList<>();
             InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
@@ -102,8 +108,8 @@ protected void check() throws Exception {
                 }
                 if (inputFileUtils.isValidOpenCGAFile(entry.getValue())) {
                     File file = inputFileUtils.getOpenCGAFile(study, entry.getValue(), token);
-                    cliParamsBuilder.append(file.getUri().getPath()).append(" ");
-                    inputFileUris.add(file.getUri().getPath());
+                    inputBindings.add(new AbstractMap.SimpleEntry<>(file.getUri().getPath(), inputDir.resolve(file.getName()).toString()));
+                    cliParamsBuilder.append(inputDir).append("/").append(file.getName()).append(" ");
                 } else {
                     cliParamsBuilder.append(entry.getValue()).append(" ");
                 }
@@ -117,31 +123,41 @@ protected void check() throws Exception {
 
     @Override
     protected void run() throws Exception {
+        Path temporalInputDir = Files.createDirectory(getOutDir().resolve(".input"));
         for (WorkflowScript script : workflow.getScripts()) {
             // Write script files
-            Files.write(getOutDir().resolve(script.getFilename()), script.getContent().getBytes());
+            Files.write(temporalInputDir.resolve(script.getFileName()), script.getContent().getBytes());
+            inputBindings.add(new AbstractMap.SimpleEntry<>(temporalInputDir.resolve(script.getFileName()).toString(),
+                    inputDir.resolve(script.getFileName()).toString()));
         }
 
         // Write nextflow.config file
         URL nextflowConfig = getClass().getResource("/nextflow.config");
         if (nextflowConfig != null) {
-            Files.copy(nextflowConfig.openStream(), getOutDir().resolve("nextflow.config"));
+            Files.copy(nextflowConfig.openStream(), temporalInputDir.resolve("nextflow.config"));
+            inputBindings.add(new AbstractMap.SimpleEntry<>(temporalInputDir.resolve("nextflow.config").toString(),
+                    inputDir.resolve("nextflow.config").toString()));
         } else {
             throw new RuntimeException("Can't fetch nextflow.config file");
         }
 
-        // Execute docker image
-        String workingDirectory = getOutDir().toAbsolutePath().toString();
+        Map<String, String> dockerParams = new HashMap<>();
+        dockerParams.put("user", "0:0");
 
+        // Build output binding
+        AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(getOutDir().toAbsolutePath().toString(),
+                outputDir);
+
+        String dockerImage = "nextflow/nextflow:" + workflow.getManager().getVersion();
         StringBuilder stringBuilder = new StringBuilder()
-                .append("nextflow -c ").append(workingDirectory).append("/nextflow.config")
-                .append(" run ");
+                .append("bash -c \"nextflow -c ").append(inputDir).append("/nextflow.config").append(" run ");
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
             stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
+            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {
-                    stringBuilder.append(workingDirectory).append("/").append(script.getFilename());
+                    stringBuilder.append(inputDir).append("/").append(script.getFileName());
                     break;
                 }
             }
@@ -149,43 +165,25 @@ protected void run() throws Exception {
         if (StringUtils.isNotEmpty(cliParams)) {
             stringBuilder.append(" ").append(cliParams);
         }
-        stringBuilder.append(" -with-report ").append(workingDirectory).append("/report.html");
-        List<String> cliArgs = Arrays.asList(StringUtils.split(stringBuilder.toString(), " "));
+        stringBuilder.append(" -with-report ").append(outputDir).append("/report.html");
+        // And give ownership permissions to the user running this process
+        stringBuilder.append("; chown -R ")
+                .append(UserProcessUtils.getUserUid()).append(":").append(UserProcessUtils.getGroupId()).append(" ").append(outputDir)
+                        .append("\"");
 
         startTraceFileMonitor();
 
+        // Execute docker image
         StopWatch stopWatch = StopWatch.createStarted();
-
-        // Execute nextflow binary
-        ProcessBuilder processBuilder = new ProcessBuilder(cliArgs);
-        // Establish the working directory of the process
-        processBuilder.directory(getOutDir().toFile());
-        logger.info("Executing: {}", stringBuilder);
-        Process p;
-        try {
-            p = processBuilder.start();
-            BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
-            BufferedReader error = new BufferedReader(new InputStreamReader(p.getErrorStream()));
-            String line;
-            while ((line = input.readLine()) != null) {
-                logger.info("{}", line);
-            }
-            while ((line = error.readLine()) != null) {
-                logger.error("{} ", line);
-            }
-            p.waitFor();
-            input.close();
-        } catch (IOException | InterruptedException e) {
-            throw new RuntimeException("Error executing cli: " + e.getMessage(), e);
-        }
-
+        DockerUtils.run(dockerImage, inputBindings, outputBinding, stringBuilder.toString(), dockerParams);
         logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
 
-        // Delete input files
+        // Delete input files and temporal directory
         for (WorkflowScript script : workflow.getScripts()) {
-            Files.delete(getOutDir().resolve(script.getFilename()));
+            Files.delete(temporalInputDir.resolve(script.getFileName()));
         }
-        Files.delete(getOutDir().resolve("nextflow.config"));
+        Files.delete(temporalInputDir.resolve("nextflow.config"));
+        Files.delete(temporalInputDir);
 
         endTraceFileMonitor();
     }
diff --git a/opencga-analysis/src/main/resources/nextflow.config b/opencga-analysis/src/main/resources/nextflow.config
index aa0b82ae0ee..fd91b7d3811 100644
--- a/opencga-analysis/src/main/resources/nextflow.config
+++ b/opencga-analysis/src/main/resources/nextflow.config
@@ -1,6 +1,6 @@
 trace {
     enabled = true
-    file = 'trace.txt'
+    file = '/data/output/trace.txt'
     overwrite = true
     fields = 'task_id,hash,name,status,start,complete,%cpu,peak_vmem'
 }
\ No newline at end of file
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index 9553bdedf20..8379877b820 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -14,10 +14,7 @@
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.file.FileCreateParams;
-import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
-import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
-import org.opencb.opencga.core.models.workflow.WorkflowRepository;
-import org.opencb.opencga.core.models.workflow.WorkflowScript;
+import org.opencb.opencga.core.models.workflow.*;
 import org.opencb.opencga.storage.core.StorageEngineFactory;
 
 import java.io.IOException;
@@ -85,6 +82,7 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         StorageConfiguration storageConfiguration = StorageConfiguration.load(inputStream, "yml");
         WorkflowCreateParams workflow = new WorkflowCreateParams()
                 .setId("workflow")
+                .setType(Workflow.Type.OTHER)
 //                .setCommandLine("run nextflow-io/rnaseq-nf -with-docker");
                 .setRepository(new WorkflowRepository("nextflow-io/rnaseq-nf"));
         catalogManager.getWorkflowManager().create(studyFqn, workflow.toWorkflow(), QueryOptions.empty(), ownerToken);
@@ -111,6 +109,7 @@ private WorkflowCreateParams createDummyWorkflow(String pipelineId) throws IOExc
         String content = IOUtils.toString(inputStream, "UTF-8");
         return new WorkflowCreateParams()
                 .setId("workflow")
+                .setType(Workflow.Type.OTHER)
                 .setScripts(Collections.singletonList(new WorkflowScript("pipeline.nf", content, true)));
     }
 }
diff --git a/opencga-analysis/src/test/resources/nextflow/pipeline_cat_file.nf b/opencga-analysis/src/test/resources/nextflow/pipeline_cat_file.nf
index afae798e218..3fa2c5745a8 100644
--- a/opencga-analysis/src/test/resources/nextflow/pipeline_cat_file.nf
+++ b/opencga-analysis/src/test/resources/nextflow/pipeline_cat_file.nf
@@ -8,7 +8,7 @@ process foo {
 
   script:
   """
-  echo `cat $params.in` world > file.out
+  echo `cat $params.in` world > /data/output/file.out
   """
 }
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 13462d52f44..4e3fb0ed759 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -563,7 +563,7 @@ private void validateNewWorkflow(Workflow workflow, String userId) throws Catalo
         workflow.setScripts(workflow.getScripts() != null ? workflow.getScripts() : Collections.emptyList());
         boolean main = false;
         for (WorkflowScript script : workflow.getScripts()) {
-            ParamUtils.checkIdentifier(script.getFilename(), SCRIPTS.key() + ".id");
+            ParamUtils.checkIdentifier(script.getFileName(), SCRIPTS.key() + ".id");
             ParamUtils.checkParameter(script.getContent(), SCRIPTS.key() + ".content");
             if (script.isMain()) {
                 if (main) {
diff --git a/opencga-client/src/main/R/R/AllGenerics.R b/opencga-client/src/main/R/R/AllGenerics.R
index 43e9f2da447..d6e8959a00c 100644
--- a/opencga-client/src/main/R/R/AllGenerics.R
+++ b/opencga-client/src/main/R/R/AllGenerics.R
@@ -30,7 +30,7 @@ setGeneric("jobClient", function(OpencgaR, job, jobs, members, endpointName, par
 
 # ##############################################################################
 ## WorkflowClient
-setGeneric("workflowClient", function(OpencgaR, workflowId, workflows, endpointName, params=NULL, ...)
+setGeneric("workflowClient", function(OpencgaR, members, workflowId, workflows, endpointName, params=NULL, ...)
     standardGeneric("workflowClient"))
 
 # ##############################################################################
diff --git a/opencga-client/src/main/R/R/Workflow-methods.R b/opencga-client/src/main/R/R/Workflow-methods.R
index 1eb79d2dccb..84e2d99f05e 100644
--- a/opencga-client/src/main/R/R/Workflow-methods.R
+++ b/opencga-client/src/main/R/R/Workflow-methods.R
@@ -19,6 +19,7 @@
 #'
 #' | endpointName | Endpoint WS | parameters accepted |
 #' | -- | :-- | --: |
+#' | updateAcl | /{apiVersion}/workflows/acl/{members}/update | study, members[*], action[*], body[*] |
 #' | create | /{apiVersion}/workflows/create | include, exclude, study, includeResult, body[*] |
 #' | distinct | /{apiVersion}/workflows/distinct | study, id, name, uuid, tags, draft, internal.registrationUserId, type, creationDate, modificationDate, acl, release, snapshot, deleted, field[*] |
 #' | run | /{apiVersion}/workflows/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
@@ -34,9 +35,19 @@
 #' [*]: Required parameter
 #' @export
 
-setMethod("workflowClient", "OpencgaR", function(OpencgaR, workflowId, workflows, endpointName, params=NULL, ...) {
+setMethod("workflowClient", "OpencgaR", function(OpencgaR, members, workflowId, workflows, endpointName, params=NULL, ...) {
     switch(endpointName,
 
+        #' @section Endpoint /{apiVersion}/workflows/acl/{members}/update:
+        #' Update the set of permissions granted for the member.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param members Comma separated list of user or group ids.
+        #' @param action Action to be performed [ADD, SET, REMOVE or RESET]. Allowed values: ['SET ADD REMOVE RESET']
+        #' @param data JSON containing the parameters to update the permissions.
+        updateAcl=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory="acl",
+                subcategoryId=members, action="update", params=params, httpMethod="POST", as.queryParam=c("action"),
+                ...),
+
         #' @section Endpoint /{apiVersion}/workflows/create:
         #' Create a workflow.
         #' @param include Fields included in the response, whole JSON path must be provided.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
index cd427ce16b4..652f15f93e1 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
@@ -25,6 +25,7 @@
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
+import org.opencb.opencga.core.models.workflow.WorkflowAclUpdateParams;
 import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
 import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
 import org.opencb.opencga.core.response.RestResponse;
@@ -50,6 +51,24 @@ public WorkflowClient(String token, ClientConfiguration configuration) {
         super(token, configuration);
     }
 
+    /**
+     * Update the set of permissions granted for the member.
+     * @param members Comma separated list of user or group ids.
+     * @param action Action to be performed [ADD, SET, REMOVE or RESET].
+     * @param data JSON containing the parameters to update the permissions.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<WorkflowAclEntryList> updateAcl(String members, String action, WorkflowAclUpdateParams data, ObjectMap params)
+            throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.putIfNotNull("action", action);
+        params.put("body", data);
+        return execute("workflows", null, "acl", members, "update", params, POST, WorkflowAclEntryList.class);
+    }
+
     /**
      * Create a workflow.
      * @param data JSON containing workflow information.
diff --git a/opencga-client/src/main/javascript/Workflow.js b/opencga-client/src/main/javascript/Workflow.js
index fd949f3af44..f2dfd10cdf9 100644
--- a/opencga-client/src/main/javascript/Workflow.js
+++ b/opencga-client/src/main/javascript/Workflow.js
@@ -34,6 +34,18 @@ export default class Workflow extends OpenCGAParentClass {
         super(config);
     }
 
+    /** Update the set of permissions granted for the member
+    * @param {String} members - Comma separated list of user or group ids.
+    * @param {Object} data - JSON containing the parameters to update the permissions.
+    * @param {"SET ADD REMOVE RESET"} action = "ADD" - Action to be performed [ADD, SET, REMOVE or RESET]. The default value is ADD.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    updateAcl(members, action, data, params) {
+        return this._post("workflows", null, "acl", members, "update", data, {action, ...params});
+    }
+
     /** Create a workflow
     * @param {Object} data - JSON containing workflow information.
     * @param {Object} [params] - The Object containing the following optional parameters:
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
index cc410139f15..fdf242702e7 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
@@ -19,6 +19,24 @@ class Workflow(_ParentRestClient):
     def __init__(self, configuration, token=None, login_handler=None, *args, **kwargs):
         super(Workflow, self).__init__(configuration, token, login_handler, *args, **kwargs)
 
+    def update_acl(self, members, action, data=None, **options):
+        """
+        Update the set of permissions granted for the member.
+        PATH: /{apiVersion}/workflows/acl/{members}/update
+
+        :param dict data: JSON containing the parameters to update the
+            permissions. (REQUIRED)
+        :param str action: Action to be performed [ADD, SET, REMOVE or RESET].
+            Allowed values: ['SET ADD REMOVE RESET'] (REQUIRED)
+        :param str members: Comma separated list of user or group ids.
+            (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        """
+
+        options['action'] = action
+        return self._post(category='workflows', resource='update', subcategory='acl', second_query_id=members, data=data, **options)
+
     def create(self, data=None, **options):
         """
         Create a workflow.
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/common/UserProcessUtils.java b/opencga-core/src/main/java/org/opencb/opencga/core/common/UserProcessUtils.java
new file mode 100644
index 00000000000..f9fe2fad7b0
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/common/UserProcessUtils.java
@@ -0,0 +1,41 @@
+package org.opencb.opencga.core.common;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+
+public class UserProcessUtils {
+
+    public static String getUserUid() {
+        try {
+            return execCommand("id -u");
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String getGroupId() {
+        try {
+            return execCommand("id -g");
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    // Method to execute a shell command and get the output
+    private static String execCommand(String command) throws Exception {
+        ProcessBuilder builder = new ProcessBuilder("sh", "-c", command);
+        Process process = builder.start();
+
+        BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
+        String line = reader.readLine(); // Read the output
+        reader.close();
+
+        int exitCode = process.waitFor();
+        if (exitCode != 0) {
+            throw new RuntimeException("Command failed with exit code: " + exitCode);
+        }
+
+        return line;
+    }
+
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowScript.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowScript.java
index 3e5f40b50f1..7cafcfbd8d7 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowScript.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowScript.java
@@ -4,8 +4,8 @@
 
 public class WorkflowScript {
 
-    @DataField(id = "filename", description = "File name")
-    private String filename;
+    @DataField(id = "fileName", description = "File name")
+    private String fileName;
 
     @DataField(id = "content", description = "Script content")
     private String content;
@@ -16,8 +16,8 @@ public class WorkflowScript {
     public WorkflowScript() {
     }
 
-    public WorkflowScript(String filename, String content, boolean main) {
-        this.filename = filename;
+    public WorkflowScript(String fileName, String content, boolean main) {
+        this.fileName = fileName;
         this.content = content;
         this.main = main;
     }
@@ -25,19 +25,19 @@ public WorkflowScript(String filename, String content, boolean main) {
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("WorkflowScript{");
-        sb.append("filename='").append(filename).append('\'');
+        sb.append("fileName='").append(fileName).append('\'');
         sb.append(", content='").append(content).append('\'');
         sb.append(", main=").append(main);
         sb.append('}');
         return sb.toString();
     }
 
-    public String getFilename() {
-        return filename;
+    public String getFileName() {
+        return fileName;
     }
 
-    public WorkflowScript setFilename(String filename) {
-        this.filename = filename;
+    public WorkflowScript setFileName(String fileName) {
+        this.fileName = fileName;
         return this;
     }
 

From 6c1456bae9d587eb00359c4d9ddbd0793ead79a4 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 19 Sep 2024 14:46:23 +0200
Subject: [PATCH 24/99] analysis: write tags and attributes in Job, #TASK-6445

---
 .../org/opencb/opencga/analysis/workflow/NextFlowExecutor.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index e25efffa376..0c0cde9a393 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -92,7 +92,7 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
-//        updateJobInformation(tags, attributes);
+        updateJobInformation(tags, attributes);
 
         this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {

From 2da90f8420df66a84e4f7fae691b04b0968f4113 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 19 Sep 2024 15:06:41 +0200
Subject: [PATCH 25/99] analysis: avoid tag duplicates, #TASK-6445

---
 .../opencb/opencga/analysis/workflow/NextFlowExecutor.java    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 0c0cde9a393..5189fcdec7b 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -84,7 +84,7 @@ protected void check() throws Exception {
         ObjectMap attributes = new ObjectMap()
                 .append("WORKFLOW_ID", workflow.getManager().getId())
                 .append("WORKFLOW_VERSION", workflow.getManager().getVersion());
-        List<String> tags = new LinkedList<>();
+        Set<String> tags = new HashSet<>();
         tags.add(ID);
         tags.add(workflow.getManager().getId().name());
         tags.add(workflow.getManager().getId() + ":" + workflow.getManager().getVersion());
@@ -92,7 +92,7 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
-        updateJobInformation(tags, attributes);
+        updateJobInformation(new ArrayList<>(tags), attributes);
 
         this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {

From 49ec23e9e84ef1248bc03bd35ad88b7759f4b657 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 19 Sep 2024 15:12:59 +0200
Subject: [PATCH 26/99] catalog: allow updating the workflow system, #TASK-6445

---
 .../catalog/db/api/WorkflowDBAdaptor.java     |  1 +
 .../db/mongodb/WorkflowMongoDBAdaptor.java    |  2 +-
 .../catalog/managers/WorkflowManager.java     | 30 +++++++++++++------
 3 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
index b235843f74f..b2ff9946d43 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
@@ -28,6 +28,7 @@ enum QueryParams implements QueryParam {
         TYPE("type", TEXT, ""),
         TAGS("tags", TEXT_ARRAY, ""),
         COMMAND_LINE("commandLine", TEXT, ""),
+        MANAGER("manager", OBJECT, ""),
         SCRIPTS("scripts", OBJECT, ""),
         VARIABLES("variables", OBJECT, ""),
         INTERNAL_REGISTRATION_USER_ID("internal.registrationUserId", TEXT, ""),
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index 5194f488d18..d84291f6f07 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -330,7 +330,7 @@ private UpdateDocument parseAndValidateUpdateParams(ObjectMap parameters, QueryO
         final String[] acceptedMapParams = {QueryParams.ATTRIBUTES.key()};
         filterMapParams(parameters, document.getSet(), acceptedMapParams);
 
-        final String[] acceptedListParams = {QueryParams.SCRIPTS.key(), QueryParams.VARIABLES.key()};
+        final String[] acceptedListParams = {QueryParams.MANAGER.key(), QueryParams.SCRIPTS.key(), QueryParams.VARIABLES.key()};
         filterObjectParams(parameters, document.getSet(), acceptedListParams);
 
 //        // Check if the scripts exist.
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 4e3fb0ed759..1dba9ec36e7 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -173,18 +173,10 @@ public OpenCGAResult<Workflow> update(String studyStr, String workflowId, Workfl
 
         JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
         CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
-        ObjectMap updateMap = null;
-        try {
-            if (updateParams != null) {
-                updateMap = new ObjectMap(getUpdateObjectMapper().writeValueAsString(updateParams));
-            }
-        } catch (JsonProcessingException e) {
-            throw new CatalogException("Could not parse WorkflowUpdateParams object: " + e.getMessage(), e);
-        }
 
         ObjectMap auditParams = new ObjectMap()
                 .append("workflowId", workflowId)
-                .append("updateParams", updateMap)
+                .append("updateParams", updateParams)
                 .append("options", options)
                 .append("token", token);
 
@@ -208,6 +200,26 @@ public OpenCGAResult<Workflow> update(String studyStr, String workflowId, Workfl
             id = workflow.getId();
             uuid = workflow.getUuid();
 
+            if (updateParams == null) {
+                throw new CatalogException("Missing parameters to update the workflow.");
+            }
+
+            if (updateParams.getManager() != null) {
+                if (updateParams.getManager().getId() == null) {
+                    throw new CatalogException("Manager id cannot be left empty.");
+                }
+                if (StringUtils.isEmpty(updateParams.getManager().getVersion())) {
+                    throw new CatalogException("Manager version cannot be left empty.");
+                }
+            }
+
+            ObjectMap updateMap;
+            try {
+                updateMap = new ObjectMap(getUpdateObjectMapper().writeValueAsString(updateParams));
+            } catch (JsonProcessingException e) {
+                throw new CatalogException("Could not parse WorkflowUpdateParams object: " + e.getMessage(), e);
+            }
+
             // 2. Update workflow object
             OpenCGAResult<Workflow> insert = getWorkflowDBAdaptor(organizationId).update(workflow.getUid(), updateMap, options);
             if (options.getBoolean(ParamConstants.INCLUDE_RESULT_PARAM)) {

From d1d2551c348ce34882c329107e92a4bc473803b0 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 19 Sep 2024 15:26:13 +0200
Subject: [PATCH 27/99] analysis: execute any workflow version, #TASK-6445

---
 .../opencga/analysis/workflow/NextFlowExecutor.java | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 5189fcdec7b..51e77236626 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -7,10 +7,12 @@
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
 import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.commons.datastore.core.Query;
 import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.commons.utils.DockerUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
 import org.opencb.opencga.analysis.utils.InputFileUtils;
+import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.common.UserProcessUtils;
@@ -70,7 +72,14 @@ protected void check() throws Exception {
             throw new IllegalArgumentException("Missing Nextflow ID");
         }
 
-        OpenCGAResult<Workflow> result = catalogManager.getWorkflowManager().get(study, nextflowParams.getId(), QueryOptions.empty(), token);
+        OpenCGAResult<Workflow> result;
+        if (nextflowParams.getVersion() != null) {
+            Query query = new Query(WorkflowDBAdaptor.QueryParams.VERSION.key(), nextflowParams.getVersion());
+            result = catalogManager.getWorkflowManager().get(study, Collections.singletonList(nextflowParams.getId()), query,
+                    QueryOptions.empty(), false, token);
+        } else {
+            result = catalogManager.getWorkflowManager().get(study, nextflowParams.getId(), QueryOptions.empty(), token);
+        }
         if (result.getNumResults() == 0) {
             throw new ToolException("Workflow '" + nextflowParams.getId() + "' not found");
         }
@@ -169,7 +178,7 @@ protected void run() throws Exception {
         // And give ownership permissions to the user running this process
         stringBuilder.append("; chown -R ")
                 .append(UserProcessUtils.getUserUid()).append(":").append(UserProcessUtils.getGroupId()).append(" ").append(outputDir)
-                        .append("\"");
+                .append("\"");
 
         startTraceFileMonitor();
 

From 37ce484bf72d5448afd3df7603ca797ed0708fcf Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 19 Sep 2024 16:24:52 +0200
Subject: [PATCH 28/99] core: set job status to ERROR if any step fails,
 #TASK-6445

---
 .../opencga/core/tools/result/ExecutionResultManager.java  | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
index aa84dcd3631..ac3171e4542 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
@@ -181,6 +181,13 @@ public synchronized ExecutionResult close(Throwable throwable) throws ToolExcept
                     break;
                 }
             }
+            for (ToolStep executionStep : execution.getSteps()) {
+                if (executionStep.getStatus().equals(Status.Type.ERROR)) {
+                    // If there is any ERROR on any step, the final status will be ERROR
+                    finalStatus = Status.Type.ERROR;
+                    break;
+                }
+            }
         } else {
             addError(throwable, execution);
             finalStatus = Status.Type.ERROR;

From 8874a65c98f711897745d5aef325c6dc46d2f5af Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 19 Sep 2024 18:37:33 +0200
Subject: [PATCH 29/99] analysis: improve nextflow parameter inputs, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 51e77236626..2fe543e0f9c 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -115,12 +115,14 @@ protected void check() throws Exception {
                 } else {
                     cliParamsBuilder.append("--").append(entry.getKey()).append(" ");
                 }
-                if (inputFileUtils.isValidOpenCGAFile(entry.getValue())) {
-                    File file = inputFileUtils.getOpenCGAFile(study, entry.getValue(), token);
-                    inputBindings.add(new AbstractMap.SimpleEntry<>(file.getUri().getPath(), inputDir.resolve(file.getName()).toString()));
-                    cliParamsBuilder.append(inputDir).append("/").append(file.getName()).append(" ");
-                } else {
-                    cliParamsBuilder.append(entry.getValue()).append(" ");
+                if (StringUtils.isNotEmpty(entry.getValue())) {
+                    if (inputFileUtils.isValidOpenCGAFile(entry.getValue())) {
+                        File file = inputFileUtils.getOpenCGAFile(study, entry.getValue(), token);
+                        inputBindings.add(new AbstractMap.SimpleEntry<>(file.getUri().getPath(), inputDir.resolve(file.getName()).toString()));
+                        cliParamsBuilder.append(inputDir).append("/").append(file.getName()).append(" ");
+                    } else {
+                        cliParamsBuilder.append(entry.getValue()).append(" ");
+                    }
                 }
             }
             this.cliParams = cliParamsBuilder.toString();
@@ -161,8 +163,9 @@ protected void run() throws Exception {
         StringBuilder stringBuilder = new StringBuilder()
                 .append("bash -c \"nextflow -c ").append(inputDir).append("/nextflow.config").append(" run ");
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
-            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
-            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
+//            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
+            stringBuilder.append(workflow.getRepository().getImage());
+//            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {

From 97768acadc778edd69f556ef864164d7cbd48f97 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 20 Sep 2024 09:45:15 +0200
Subject: [PATCH 30/99] catalog: add profile exception, #TASK-6445

---
 .../org/opencb/opencga/catalog/managers/JobManager.java     | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
index b8b9ba55bae..8816e30f010 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
@@ -379,7 +379,6 @@ private void autoCompleteNewJob(String organizationId, Study study, Job job, Jwt
             job.setInput(Collections.emptyList());
         } else {
             // We only check input files if the job does not depend on other job that might be creating the necessary file.
-
             List<File> inputFiles = getJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
             job.setInput(inputFiles);
         }
@@ -458,9 +457,10 @@ public List<File> getJobInputFilesFromParams(String study, Job job, String token
                     // We look for files in the dynamic params
                     Map<String, Object> dynamicParams = (Map<String, Object>) entry.getValue();
                     for (Map.Entry<String, Object> subEntry : dynamicParams.entrySet()) {
-                        if (subEntry.getKey().toLowerCase().endsWith(fileParamSuffix)) {
+                        String subEntryKey = subEntry.getKey().toLowerCase();
+                        if (!subEntryKey.contains("profile") && subEntryKey.endsWith(fileParamSuffix)) {
                             // We assume that every variable ending in 'file' corresponds to input files that need to be accessible in
-                            // catalog
+                            // catalog (except words such as 'profile')
                             try {
                                 // Validate the user has access to the file
                                 File file = catalogManager.getFileManager().get(study, (String) subEntry.getValue(),

From cdb2e89bd1d943c13f28df7767f4df3aa6a62923 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 20 Sep 2024 10:11:54 +0200
Subject: [PATCH 31/99] analysis: improve executor to accept fields with -,
 #TASK-6445

---
 .../org/opencb/opencga/analysis/workflow/NextFlowExecutor.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 2fe543e0f9c..3e88952c127 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -110,7 +110,7 @@ protected void check() throws Exception {
 
             StringBuilder cliParamsBuilder = new StringBuilder();
             for (Map.Entry<String, String> entry : nextflowParams.getParams().entrySet()) {
-                if (entry.getKey().startsWith("--")) {
+                if (entry.getKey().startsWith("-")) {
                     cliParamsBuilder.append(entry.getKey()).append(" ");
                 } else {
                     cliParamsBuilder.append("--").append(entry.getKey()).append(" ");

From 857b41da63842d804e52dcab1a9395d10a2cd11d Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 20 Sep 2024 12:43:33 +0200
Subject: [PATCH 32/99] core: add minimumRequirements to Workflow, #TASK-6445

---
 .../analysis/binary/BinaryExecutor.java       |  2 +-
 .../analysis/workflow/NextFlowExecutor.java   |  2 +-
 .../opencga/catalog/managers/JobManager.java  | 54 +++++++++++++++++--
 .../catalog/managers/WorkflowManager.java     |  2 +-
 .../catalog}/utils/InputFileUtils.java        |  5 +-
 .../opencga/core/api/FieldConstants.java      |  5 ++
 .../core/models/workflow/Workflow.java        | 19 ++++++-
 .../models/workflow/WorkflowCreateParams.java | 23 ++++++--
 .../workflow/WorkflowMinimumRequirements.java | 48 +++++++++++++++++
 .../models/workflow/WorkflowUpdateParams.java |  8 ++-
 10 files changed, 150 insertions(+), 18 deletions(-)
 rename {opencga-analysis/src/main/java/org/opencb/opencga/analysis => opencga-catalog/src/main/java/org/opencb/opencga/catalog}/utils/InputFileUtils.java (92%)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
index 3ef8fd442cc..a582723a425 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
@@ -5,7 +5,7 @@
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.utils.DockerUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
-import org.opencb.opencga.analysis.utils.InputFileUtils;
+import org.opencb.opencga.catalog.utils.InputFileUtils;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 3e88952c127..a6cd07e4649 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -11,7 +11,7 @@
 import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.commons.utils.DockerUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
-import org.opencb.opencga.analysis.utils.InputFileUtils;
+import org.opencb.opencga.catalog.utils.InputFileUtils;
 import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
index 8816e30f010..8bbafa9d7d9 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
@@ -37,6 +37,7 @@
 import org.opencb.opencga.catalog.io.IOManagerFactory;
 import org.opencb.opencga.catalog.models.InternalGetDataResult;
 import org.opencb.opencga.catalog.utils.CatalogFqn;
+import org.opencb.opencga.catalog.utils.InputFileUtils;
 import org.opencb.opencga.catalog.utils.ParamUtils;
 import org.opencb.opencga.catalog.utils.UuidUtils;
 import org.opencb.opencga.core.api.FieldConstants;
@@ -379,7 +380,12 @@ private void autoCompleteNewJob(String organizationId, Study study, Job job, Jwt
             job.setInput(Collections.emptyList());
         } else {
             // We only check input files if the job does not depend on other job that might be creating the necessary file.
-            List<File> inputFiles = getJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
+            List<File> inputFiles;
+            if (job.getTool().getId().equalsIgnoreCase("binary") || job.getTool().getId().equalsIgnoreCase("workflow")) {
+                inputFiles = getWorkflowJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
+            } else {
+                inputFiles = getJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
+            }
             job.setInput(inputFiles);
         }
 
@@ -433,7 +439,6 @@ public OpenCGAResult<Job> kill(String studyStr, String jobId, String token) thro
         }
     }
 
-
     public List<File> getJobInputFilesFromParams(String study, Job job, String token) throws CatalogException {
         // Look for input files
         String fileParamSuffix = "file";
@@ -457,10 +462,9 @@ public List<File> getJobInputFilesFromParams(String study, Job job, String token
                     // We look for files in the dynamic params
                     Map<String, Object> dynamicParams = (Map<String, Object>) entry.getValue();
                     for (Map.Entry<String, Object> subEntry : dynamicParams.entrySet()) {
-                        String subEntryKey = subEntry.getKey().toLowerCase();
-                        if (!subEntryKey.contains("profile") && subEntryKey.endsWith(fileParamSuffix)) {
+                        if (subEntry.getKey().toLowerCase().endsWith(fileParamSuffix)) {
                             // We assume that every variable ending in 'file' corresponds to input files that need to be accessible in
-                            // catalog (except words such as 'profile')
+                            // catalog
                             try {
                                 // Validate the user has access to the file
                                 File file = catalogManager.getFileManager().get(study, (String) subEntry.getValue(),
@@ -478,6 +482,46 @@ public List<File> getJobInputFilesFromParams(String study, Job job, String token
         return inputFiles;
     }
 
+    public List<File> getWorkflowJobInputFilesFromParams(String study, Job job, String token) throws CatalogException {
+        InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
+        // Look for input files
+        List<File> inputFiles = new ArrayList<>();
+        if (job.getParams() != null) {
+            for (Map.Entry<String, Object> entry : job.getParams().entrySet()) {
+                if (entry.getValue() instanceof String) {
+                    String fileStr = (String) entry.getValue();
+                    if (inputFileUtils.isValidOpenCGAFile(fileStr)) {
+                        try {
+                            File file = inputFileUtils.getOpenCGAFile(study, fileStr, token);
+                            inputFiles.add(file);
+                        } catch (CatalogException e) {
+                            throw new CatalogException("Cannot find file '" + entry.getValue() + "' from job param '" + entry.getKey()
+                                    + "'; (study = " + study + ") :" + e.getMessage(), e);
+                        }
+                    }
+                } else if (entry.getValue() instanceof Map) {
+                    // We look for files in the dynamic params
+                    Map<String, Object> dynamicParams = (Map<String, Object>) entry.getValue();
+                    for (Map.Entry<String, Object> subEntry : dynamicParams.entrySet()) {
+                        if (subEntry.getValue() instanceof String) {
+                            String fileStr = (String) subEntry.getValue();
+                            if (inputFileUtils.isValidOpenCGAFile(fileStr)) {
+                                try {
+                                    File file = inputFileUtils.getOpenCGAFile(study, fileStr, token);
+                                    inputFiles.add(file);
+                                } catch (CatalogException e) {
+                                    throw new CatalogException("Cannot find file '" + subEntry.getValue() + "' from variable '"
+                                            + entry.getKey() + "." + subEntry.getKey() + "'. ", e);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return inputFiles;
+    }
+
     public OpenCGAResult<Job> retry(String studyStr, JobRetryParams jobRetry, Enums.Priority priority, String jobId, String jobDescription,
                                     List<String> jobDependsOn, List<String> jobTags, String jobScheduledStartTime, String token)
             throws CatalogException {
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 1dba9ec36e7..e6b443889b6 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -561,7 +561,6 @@ private WorkflowDBAdaptor.QueryParams getFieldFilter(List<String> idList) throws
 
     private void validateNewWorkflow(Workflow workflow, String userId) throws CatalogParameterException {
         ParamUtils.checkIdentifier(workflow.getId(), ID.key());
-        ParamUtils.checkObj(workflow.getType(), TYPE.key());
         if (workflow.getManager() == null) {
             workflow.setManager(new WorkflowSystem());
         }
@@ -571,6 +570,7 @@ private void validateNewWorkflow(Workflow workflow, String userId) throws Catalo
         if (StringUtils.isEmpty(workflow.getManager().getVersion())) {
             workflow.getManager().setVersion("24.04.4");
         }
+        workflow.setType(ParamUtils.defaultObject(workflow.getType(), Workflow.Type.OTHER));
         workflow.setTags(workflow.getTags() != null ? workflow.getTags() : Collections.emptyList());
         workflow.setScripts(workflow.getScripts() != null ? workflow.getScripts() : Collections.emptyList());
         boolean main = false;
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
similarity index 92%
rename from opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java
rename to opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
index e1aafcab329..6ed37259365 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/utils/InputFileUtils.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
@@ -1,4 +1,4 @@
-package org.opencb.opencga.analysis.utils;
+package org.opencb.opencga.catalog.utils;
 
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.managers.CatalogManager;
@@ -16,8 +16,7 @@ public class InputFileUtils {
     private final CatalogManager catalogManager;
 
     private static final Pattern OPERATION_PATTERN = Pattern.compile("^(?i)(ocga://|opencga://|file://)(.+)$");
-
-    private final static Logger logger = LoggerFactory.getLogger(InputFileUtils.class);
+    private final Logger logger = LoggerFactory.getLogger(InputFileUtils.class);
 
     public InputFileUtils(CatalogManager catalogManager) {
         this.catalogManager = catalogManager;
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index 0e9d9b7f809..1aa1f1ab25a 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -317,8 +317,13 @@ public class FieldConstants {
     public static final String WORKFLOW_SCRIPTS_DESCRIPTION = "List of scripts used by the Workflow.";
     public static final String WORKFLOW_TAGS_DESCRIPTION = "List of tags.";
     public static final String WORKFLOW_VARIABLES_DESCRIPTION = "List of variables accepted by the Workflow.";
+    public static final String WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION = "Minimum requirements to execute the workflow.";
     public static final String WORKFLOW_INTERNAL_DESCRIPTION = "Workflow internal information.";
 
+    public static final String WORKFLOW_MIN_REQUIREMENTS_CPU_DESCRIPTION = "Minimum number of cpu cores required to execute the workflow.";
+    public static final String WORKFLOW_MIN_REQUIREMENTS_MEMORY_DESCRIPTION = "Minimum memory required to execute the workflow"
+            + " (expressed in GB).";
+
     public static final String WORKFLOW_SYSTEM_ID_DESCRIPTION = "Workflow system id. Valid values: NEXTFLOW.";
     public static final String WORKFLOW_SYSTEM_VERSION_DESCRIPTION = "Workflow system version to use.";
 
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index 4e6398a3ab3..8b81d614129 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -51,6 +51,9 @@ public class Workflow extends PrivateStudyUid {
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
     private List<Variable> variables;
 
+    @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
+    private WorkflowMinimumRequirements minimumRequirements;
+
     @DataField(id = "internal", description = FieldConstants.WORKFLOW_INTERNAL_DESCRIPTION)
     private WorkflowInternal internal;
 
@@ -66,7 +69,7 @@ public class Workflow extends PrivateStudyUid {
     public enum Type {
         CLINICAL_INTERPRETATION,
         SECONDARY_ANALYSIS,
-        RESEARCH,
+        RESEARCH_ANALYSIS,
         OTHER
     }
 
@@ -75,7 +78,8 @@ public Workflow() {
 
     public Workflow(String id, String name, String description, boolean draft, Type type, WorkflowSystem manager,
                     WorkflowRepository repository, List<WorkflowScript> scripts, List<String> tags, List<Variable> variables,
-                    WorkflowInternal internal, String creationDate, String modificationDate, Map<String, Object> attributes) {
+                    WorkflowMinimumRequirements minimumRequirements, WorkflowInternal internal, String creationDate,
+                    String modificationDate, Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
         this.description = description;
@@ -86,6 +90,7 @@ public Workflow(String id, String name, String description, boolean draft, Type
         this.scripts = scripts;
         this.tags = tags;
         this.variables = variables;
+        this.minimumRequirements = minimumRequirements;
         this.internal = internal;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
@@ -108,6 +113,7 @@ public String toString() {
         sb.append(", scripts=").append(scripts);
         sb.append(", tags=").append(tags);
         sb.append(", variables=").append(variables);
+        sb.append(", minimumRequirements=").append(minimumRequirements);
         sb.append(", internal=").append(internal);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
@@ -240,6 +246,15 @@ public Workflow setVariables(List<Variable> variables) {
         return this;
     }
 
+    public WorkflowMinimumRequirements getMinimumRequirements() {
+        return minimumRequirements;
+    }
+
+    public Workflow setMinimumRequirements(WorkflowMinimumRequirements minimumRequirements) {
+        this.minimumRequirements = minimumRequirements;
+        return this;
+    }
+
     public WorkflowInternal getInternal() {
         return internal;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
index fd624e419f9..9e59feccc04 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -37,6 +37,9 @@ public class WorkflowCreateParams {
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
     private List<Variable> variables;
 
+    @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
+    private WorkflowMinimumRequirements minimumRequirements;
+
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
     private List<WorkflowScript> scripts;
 
@@ -53,8 +56,9 @@ public WorkflowCreateParams() {
     }
 
     public WorkflowCreateParams(String id, String name, String description, WorkflowSystem manager, Workflow.Type type, List<String> tags,
-                                boolean draft, WorkflowRepository repository, List<Variable> variables, List<WorkflowScript> scripts,
-                                String creationDate, String modificationDate, Map<String, Object> attributes) {
+                                boolean draft, WorkflowRepository repository, List<Variable> variables,
+                                WorkflowMinimumRequirements minimumRequirements, List<WorkflowScript> scripts, String creationDate,
+                                String modificationDate, Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
         this.description = description;
@@ -64,6 +68,7 @@ public WorkflowCreateParams(String id, String name, String description, Workflow
         this.draft = draft;
         this.repository = repository;
         this.variables = variables;
+        this.minimumRequirements = minimumRequirements;
         this.scripts = scripts;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
@@ -82,6 +87,7 @@ public String toString() {
         sb.append(", draft=").append(draft);
         sb.append(", repository=").append(repository);
         sb.append(", variables=").append(variables);
+        sb.append(", minimumRequirements=").append(minimumRequirements);
         sb.append(", scripts=").append(scripts);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
@@ -91,8 +97,8 @@ public String toString() {
     }
 
     public Workflow toWorkflow() {
-        return new Workflow(id, name, description, draft, type, manager, repository, scripts, tags, variables, new WorkflowInternal(),
-                creationDate, modificationDate, attributes);
+        return new Workflow(id, name, description, draft, type, manager, repository, scripts, tags, variables, minimumRequirements,
+                new WorkflowInternal(), creationDate, modificationDate, attributes);
     }
 
     public String getId() {
@@ -176,6 +182,15 @@ public WorkflowCreateParams setVariables(List<Variable> variables) {
         return this;
     }
 
+    public WorkflowMinimumRequirements getMinimumRequirements() {
+        return minimumRequirements;
+    }
+
+    public WorkflowCreateParams setMinimumRequirements(WorkflowMinimumRequirements minimumRequirements) {
+        this.minimumRequirements = minimumRequirements;
+        return this;
+    }
+
     public List<WorkflowScript> getScripts() {
         return scripts;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
new file mode 100644
index 00000000000..c07a1d6801c
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
@@ -0,0 +1,48 @@
+package org.opencb.opencga.core.models.workflow;
+
+import org.opencb.commons.annotations.DataField;
+import org.opencb.opencga.core.api.FieldConstants;
+
+public class WorkflowMinimumRequirements {
+
+    @DataField(id = "cpu", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_CPU_DESCRIPTION)
+    private int cpu;
+
+    @DataField(id = "memory", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_MEMORY_DESCRIPTION)
+    private int memory;
+
+    public WorkflowMinimumRequirements() {
+    }
+
+    public WorkflowMinimumRequirements(int cpu, int memory) {
+        this.cpu = cpu;
+        this.memory = memory;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowMinimumRequirements{");
+        sb.append("cpu=").append(cpu);
+        sb.append(", memory=").append(memory);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public int getCpu() {
+        return cpu;
+    }
+
+    public WorkflowMinimumRequirements setCpu(int cpu) {
+        this.cpu = cpu;
+        return this;
+    }
+
+    public int getMemory() {
+        return memory;
+    }
+
+    public WorkflowMinimumRequirements setMemory(int memory) {
+        this.memory = memory;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
index ba09ed1c219..fdcdb0697df 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
@@ -36,6 +36,9 @@ public class WorkflowUpdateParams {
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
     private List<Variable> variables;
 
+    @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
+    private WorkflowMinimumRequirements minimumRequirements;
+
     @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
 
@@ -50,7 +53,8 @@ public WorkflowUpdateParams() {
 
     public WorkflowUpdateParams(String name, String description, WorkflowSystem manager, Workflow.Type type, List<String> tags,
                                 boolean draft, WorkflowRepository repository, List<WorkflowScript> scripts, List<Variable> variables,
-                                String creationDate, String modificationDate, Map<String, Object> attributes) {
+                                WorkflowMinimumRequirements minimumRequirements, String creationDate, String modificationDate,
+                                Map<String, Object> attributes) {
         this.name = name;
         this.description = description;
         this.manager = manager;
@@ -60,6 +64,7 @@ public WorkflowUpdateParams(String name, String description, WorkflowSystem mana
         this.repository = repository;
         this.scripts = scripts;
         this.variables = variables;
+        this.minimumRequirements = minimumRequirements;
         this.creationDate = creationDate;
         this.modificationDate = modificationDate;
         this.attributes = attributes;
@@ -77,6 +82,7 @@ public String toString() {
         sb.append(", repository=").append(repository);
         sb.append(", scripts=").append(scripts);
         sb.append(", variables=").append(variables);
+        sb.append(", minimumRequirements=").append(minimumRequirements);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
         sb.append(", attributes=").append(attributes);

From c6df368266724161538986787887ea028241c8ff Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 20 Sep 2024 13:12:30 +0200
Subject: [PATCH 33/99] core: add new tool externalExecutor object to Job,
 #TASK-6445

---
 .../analysis/binary/BinaryExecutor.java       |  8 ++--
 .../analysis/tools/OpenCgaToolScopeStudy.java | 13 +++---
 .../analysis/workflow/NextFlowExecutor.java   |  7 ++-
 .../main/executors/JobsCommandExecutor.java   |  1 +
 .../cli/main/options/JobsCommandOptions.java  |  8 ++--
 .../opencga/catalog/db/api/JobDBAdaptor.java  |  1 +
 .../catalog/db/mongodb/JobMongoDBAdaptor.java |  3 +-
 .../opencga/core/api/FieldConstants.java      |  2 +
 .../opencga/core/models/job/ToolInfo.java     | 45 ++++++++++++-------
 .../core/models/job/ToolInfoExecutor.java     | 42 +++++++++++++++++
 10 files changed, 95 insertions(+), 35 deletions(-)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfoExecutor.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
index a582723a425..a4f162f6490 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
@@ -2,7 +2,6 @@
 
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
-import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.utils.DockerUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
 import org.opencb.opencga.catalog.utils.InputFileUtils;
@@ -12,6 +11,7 @@
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.job.JobRunDockerParams;
 import org.opencb.opencga.core.models.job.JobRunParams;
+import org.opencb.opencga.core.models.job.ToolInfoExecutor;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
 import org.slf4j.Logger;
@@ -60,13 +60,11 @@ protected void check() throws Exception {
         }
 
         // Update job tags and attributes
-        ObjectMap attributes = new ObjectMap()
-                .append("DOCKER_ID", runParams.getDocker().getId())
-                .append("DOCKER_TAG", runParams.getDocker().getTag());
+        ToolInfoExecutor toolInfoExecutor = new ToolInfoExecutor(runParams.getDocker().getId(), runParams.getDocker().getTag());
         List<String> tags = new LinkedList<>();
         tags.add(ID);
         tags.add(this.dockerImage);
-        updateJobInformation(tags, attributes);
+        updateJobInformation(tags, toolInfoExecutor);
 
         // Build input bindings
         this.inputBindings = new LinkedList<>();
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
index 39c4282109d..9e49423c7eb 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
@@ -18,10 +18,11 @@
 
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.opencga.catalog.db.api.JobDBAdaptor;
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.managers.StudyManager;
 import org.opencb.opencga.core.api.ParamConstants;
-import org.opencb.opencga.core.models.job.JobUpdateParams;
+import org.opencb.opencga.core.models.job.ToolInfoExecutor;
 
 import java.util.List;
 
@@ -55,11 +56,11 @@ protected final String getStudyFqn() throws CatalogException {
                 getToken()).first().getFqn();
     }
 
-    protected void updateJobInformation(List<String> tags, ObjectMap attributes) throws CatalogException {
-        JobUpdateParams updateParams = new JobUpdateParams()
-                .setTags(tags)
-                .setAttributes(attributes);
-        catalogManager.getJobManager().update(getStudyFqn(), getJobId(), updateParams, QueryOptions.empty(), token);
+    protected void updateJobInformation(List<String> tags, ToolInfoExecutor executor) throws CatalogException {
+        ObjectMap params = new ObjectMap()
+                .append(JobDBAdaptor.QueryParams.TAGS.key(), tags)
+                .append(JobDBAdaptor.QueryParams.TOOL_EXTERNAL_EXECUTOR.key(), executor);
+        catalogManager.getJobManager().update(getStudyFqn(), getJobId(), params, QueryOptions.empty(), token);
     }
 
 }
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index a6cd07e4649..9fe07de30ae 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -19,6 +19,7 @@
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.file.File;
+import org.opencb.opencga.core.models.job.ToolInfoExecutor;
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.models.workflow.WorkflowScript;
@@ -90,9 +91,7 @@ protected void check() throws Exception {
         }
 
         // Update job tags and attributes
-        ObjectMap attributes = new ObjectMap()
-                .append("WORKFLOW_ID", workflow.getManager().getId())
-                .append("WORKFLOW_VERSION", workflow.getManager().getVersion());
+        ToolInfoExecutor toolInfoExecutor = new ToolInfoExecutor(workflow.getManager().getId().name(), workflow.getManager().getVersion());
         Set<String> tags = new HashSet<>();
         tags.add(ID);
         tags.add(workflow.getManager().getId().name());
@@ -101,7 +100,7 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
-        updateJobInformation(new ArrayList<>(tags), attributes);
+        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
 
         this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
index e30abec6bcb..ba48c6db8f9 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
@@ -29,6 +29,7 @@
 import org.opencb.opencga.core.models.job.JobTop;
 import org.opencb.opencga.core.models.job.JobUpdateParams;
 import org.opencb.opencga.core.models.job.ToolInfo;
+import org.opencb.opencga.core.models.job.ToolInfoExecutor;
 import org.opencb.opencga.core.response.QueryType;
 import org.opencb.opencga.core.response.RestResponse;
 import org.opencb.opencga.core.tools.annotations.Tool;
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
index 9f7e2928f6c..2dc71a214e3 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
@@ -120,16 +120,16 @@ public class CreateCommandOptions {
         public String toolId;
     
         @Parameter(names = {"--tool-description"}, description = "Users may provide a description for the entry.", required = false, arity = 1)
-        public String toolDescription = "No description available";
+        public String toolDescription;
     
         @Parameter(names = {"--tool-scope"}, description = "Tool info scope can have the values GLOBAL, PROJECT and STUDY.", required = false, arity = 1)
-        public String toolScope = "No description available";
+        public String toolScope;
     
         @Parameter(names = {"--tool-type"}, description = "Tool info type can have the values OPERATION and ANALYSIS.", required = false, arity = 1)
-        public String toolType = "No description available";
+        public String toolType;
     
         @Parameter(names = {"--tool-resource"}, description = "Tool info resource can have the values AUDIT, USER, PROJECT, STUDY, FILE, SAMPLE, JOB, INDIVIDUAL, COHORT, DISEASE_PANEL, FAMILY, CLINICAL_ANALYSIS, INTERPRETATION, VARIANT, ALIGNMENT, CLINICAL, EXPRESSION, RGA and FUNCTIONAL.", required = false, arity = 1)
-        public String toolResource = "No description available";
+        public String toolResource;
     
         @Parameter(names = {"--priority"}, description = "The body web service priority parameter", required = false, arity = 1)
         public String priority;
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/JobDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/JobDBAdaptor.java
index a6016da7441..a8f1e717cae 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/JobDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/JobDBAdaptor.java
@@ -113,6 +113,7 @@ enum QueryParams implements QueryParam {
         TOOL("tool", OBJECT, ""),
         TOOL_ID("tool.id", TEXT, ""),
         TOOL_TYPE("tool.type", TEXT, ""),
+        TOOL_EXTERNAL_EXECUTOR("tool.externalExecutor", OBJECT, ""),
 
         PRIORITY("priority", TEXT, ""),
 
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/JobMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/JobMongoDBAdaptor.java
index 53c9a5f157e..cb59d9dca0b 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/JobMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/JobMongoDBAdaptor.java
@@ -441,7 +441,8 @@ private UpdateDocument parseAndValidateUpdateParams(ObjectMap parameters, QueryO
                     Enums.Priority.getPriority(parameters.getString(QueryParams.PRIORITY.key())).getValue());
         }
 
-        String[] acceptedObjectParams = {QueryParams.EXECUTION.key(), QueryParams.STUDY.key(), QueryParams.INTERNAL_STATUS.key()};
+        String[] acceptedObjectParams = {QueryParams.EXECUTION.key(), QueryParams.STUDY.key(), QueryParams.INTERNAL_STATUS.key(),
+                QueryParams.TOOL_EXTERNAL_EXECUTOR.key()};
         filterObjectParams(parameters, document.getSet(), acceptedObjectParams);
 
         if (document.getSet().containsKey(QueryParams.STUDY.key())) {
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index 1aa1f1ab25a..18a81a14a2c 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -305,6 +305,8 @@ public class FieldConstants {
     public static final String TOOL_INFO_RESOURCE_DESCRIPTION = "Tool info resource can have the values AUDIT, USER, PROJECT, "
             + "STUDY, FILE, SAMPLE, JOB, INDIVIDUAL, COHORT, DISEASE_PANEL, FAMILY, CLINICAL_ANALYSIS, INTERPRETATION, "
             + "VARIANT, ALIGNMENT, CLINICAL, EXPRESSION, RGA and FUNCTIONAL.";
+    public static final String TOOL_INFO_EXTERNAL_EXECUTOR_DESCRIPTION = "Object containing the id and version of the external tool that"
+            + " is being executed.";
 
     // Workflow
     public static final String WORKFLOW_ID_DESCRIPTION = "Workflow ID.";
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
index 8c5600e416c..81db952fcfb 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
@@ -29,43 +29,49 @@ public class ToolInfo {
             description = FieldConstants.GENERIC_ID_DESCRIPTION)
     private String id;
 
-    @DataField(id = "description", defaultValue = "No description available",
-            description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
+    @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
-    @DataField(id = "scope", defaultValue = "No description available",
-            description = FieldConstants.TOOL_INFO_SCOPE_DESCRIPTION)
+    @DataField(id = "scope", description = FieldConstants.TOOL_INFO_SCOPE_DESCRIPTION)
     private Scope scope;
 
-    @DataField(id = "type", defaultValue = "No description available",
-            description = FieldConstants.TOOL_INFO_TYPE_DESCRIPTION)
+    @DataField(id = "type", description = FieldConstants.TOOL_INFO_TYPE_DESCRIPTION)
     private Type type;
 
-    @DataField(id = "resource", defaultValue = "No description available",
-            description = FieldConstants.TOOL_INFO_RESOURCE_DESCRIPTION)
+    @DataField(id = "resource", description = FieldConstants.TOOL_INFO_RESOURCE_DESCRIPTION)
     private Enums.Resource resource;
 
+    @DataField(id = "resource", description = FieldConstants.TOOL_INFO_EXTERNAL_EXECUTOR_DESCRIPTION)
+    private ToolInfoExecutor externalExecutor;
+
 
     public ToolInfo() {
     }
 
     public ToolInfo(String id, String description, Scope scope, Type type, Enums.Resource resource) {
+        this(id, description, scope, type, resource, null);
+    }
+
+    public ToolInfo(String id, String description, Scope scope, Type type, Enums.Resource resource, ToolInfoExecutor externalExecutor) {
         this.id = id;
         this.description = description;
         this.scope = scope;
         this.type = type;
         this.resource = resource;
+        this.externalExecutor = externalExecutor;
     }
 
     @Override
     public String toString() {
-        return "ToolInfo{" +
-                "id='" + id + '\'' +
-                ", description='" + description + '\'' +
-                ", scope=" + scope +
-                ", type=" + type +
-                ", resource=" + resource +
-                '}';
+        final StringBuilder sb = new StringBuilder("ToolInfo{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", description='").append(description).append('\'');
+        sb.append(", scope=").append(scope);
+        sb.append(", type=").append(type);
+        sb.append(", resource=").append(resource);
+        sb.append(", externalExecutor=").append(externalExecutor);
+        sb.append('}');
+        return sb.toString();
     }
 
     public String getId() {
@@ -112,4 +118,13 @@ public ToolInfo setResource(Enums.Resource resource) {
         this.resource = resource;
         return this;
     }
+
+    public ToolInfoExecutor getExternalExecutor() {
+        return externalExecutor;
+    }
+
+    public ToolInfo setExternalExecutor(ToolInfoExecutor externalExecutor) {
+        this.externalExecutor = externalExecutor;
+        return this;
+    }
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfoExecutor.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfoExecutor.java
new file mode 100644
index 00000000000..0a6552c5559
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfoExecutor.java
@@ -0,0 +1,42 @@
+package org.opencb.opencga.core.models.job;
+
+public class ToolInfoExecutor {
+
+    private String id;
+    private String version;
+
+    public ToolInfoExecutor() {
+    }
+
+    public ToolInfoExecutor(String id, String version) {
+        this.id = id;
+        this.version = version;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("ToolInfoExecutor{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", version='").append(version).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public ToolInfoExecutor setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public ToolInfoExecutor setVersion(String version) {
+        this.version = version;
+        return this;
+    }
+}

From 3f22551411cb5dcb215e71b79f098c68fa490131 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 20 Sep 2024 15:38:44 +0200
Subject: [PATCH 34/99] analysis: mount docker socket, #TASK-6445

---
 .../opencga/analysis/workflow/NextFlowExecutor.java | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 9fe07de30ae..fc4d3e6e579 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -11,11 +11,10 @@
 import org.opencb.commons.datastore.core.QueryOptions;
 import org.opencb.commons.utils.DockerUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
-import org.opencb.opencga.catalog.utils.InputFileUtils;
 import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
+import org.opencb.opencga.catalog.utils.InputFileUtils;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
-import org.opencb.opencga.core.common.UserProcessUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.file.File;
@@ -164,7 +163,7 @@ protected void run() throws Exception {
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
-//            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
+            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {
@@ -177,10 +176,10 @@ protected void run() throws Exception {
             stringBuilder.append(" ").append(cliParams);
         }
         stringBuilder.append(" -with-report ").append(outputDir).append("/report.html");
-        // And give ownership permissions to the user running this process
-        stringBuilder.append("; chown -R ")
-                .append(UserProcessUtils.getUserUid()).append(":").append(UserProcessUtils.getGroupId()).append(" ").append(outputDir)
-                .append("\"");
+//        // And give ownership permissions to the user running this process
+//        stringBuilder.append("; chown -R ")
+//                .append(UserProcessUtils.getUserUid()).append(":").append(UserProcessUtils.getGroupId()).append(" ").append(outputDir)
+//                .append("\"");
 
         startTraceFileMonitor();
 

From 612c60beb3d899c192f5acfe5bbdfe8ea8b69a19 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 20 Sep 2024 16:00:27 +0200
Subject: [PATCH 35/99] analysis: add missing trailing quote, #TASK-6445

---
 .../org/opencb/opencga/analysis/workflow/NextFlowExecutor.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index fc4d3e6e579..ba557e5bf56 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -175,7 +175,7 @@ protected void run() throws Exception {
         if (StringUtils.isNotEmpty(cliParams)) {
             stringBuilder.append(" ").append(cliParams);
         }
-        stringBuilder.append(" -with-report ").append(outputDir).append("/report.html");
+        stringBuilder.append(" -with-report ").append(outputDir).append("/report.html\"");
 //        // And give ownership permissions to the user running this process
 //        stringBuilder.append("; chown -R ")
 //                .append(UserProcessUtils.getUserUid()).append(":").append(UserProcessUtils.getGroupId()).append(" ").append(outputDir)

From f625346966ef9df092b28e4fa37f84e7c6904a29 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sun, 22 Sep 2024 18:23:16 +0100
Subject: [PATCH 36/99] core@ review workflow and job data models and their
 indexes

---
 .../src/main/resources/catalog-indexes.txt    |  35 +++--
 .../src/main/javascript/Workflow.js           |   2 +-
 .../opencb/opencga/core/models/job/Job.java   | 127 +++++-------------
 .../opencga/core/models/job/JobInternal.java  |   9 +-
 .../opencga/core/models/job/ToolInfo.java     |   2 +-
 .../core/models/workflow/Workflow.java        |  50 +++----
 .../models/workflow/WorkflowCreateParams.java |   2 +-
 7 files changed, 87 insertions(+), 140 deletions(-)

diff --git a/opencga-catalog/src/main/resources/catalog-indexes.txt b/opencga-catalog/src/main/resources/catalog-indexes.txt
index 68b95c84215..eb2c34d47fb 100644
--- a/opencga-catalog/src/main/resources/catalog-indexes.txt
+++ b/opencga-catalog/src/main/resources/catalog-indexes.txt
@@ -1,21 +1,10 @@
-{"collections": ["note", "note_archive"], "fields": {"id": 1, "studyUid": 1, "version": 1}, "options": {"unique": true}}
-{"collections": ["note", "note_archive"], "fields": {"uid": 1, "version": 1}, "options": {"unique": true}}
-{"collections": ["note", "note_archive"], "fields": {"uuid": 1, "version": 1}, "options": {"unique": true}}
-{"collections": ["note", "note_archive"], "fields": {"scope": 1, "studyUid": 1}, "options": {}}
-{"collections": ["note", "note_archive"], "fields": {"studyUid": 1}, "options": {}}
-{"collections": ["note", "note_archive"], "fields": {"visibility": 1, "studyUid": 1}, "options": {}}
-{"collections": ["note", "note_archive"], "fields": {"userId": 1, "studyUid": 1}, "options": {}}
-{"collections": ["note", "note_archive"], "fields": {"tags": 1, "studyUid": 1}, "options": {}}
-{"collections": ["note", "note_archive"], "fields": {"_creationDate": 1, "studyUid": 1}, "options": {}}
-{"collections": ["note", "note_archive"], "fields": {"_modificationDate": 1, "studyUid": 1}, "options": {}}
+{"collections": ["user"], "fields": {"id": 1}, "options": {"unique": true}}
 
 {"collections": ["project"], "fields": {"id": 1}, "options": {"unique": true}}
 {"collections": ["project"], "fields": {"uid": 1}, "options": {"unique": true}}
 {"collections": ["project"], "fields": {"uuid": 1}, "options": {"unique": true}}
 {"collections": ["project"], "fields": {"fqn": 1}, "options": {"unique": true}}
 
-{"collections": ["user"], "fields": {"id": 1}, "options": {"unique": true}}
-
 {"collections": ["study"], "fields": {"uid": 1}, "options": {"unique": true}}
 {"collections": ["study"], "fields": {"uuid": 1}, "options": {"unique": true}}
 {"collections": ["study"], "fields": {"fqn": 1}, "options": {"unique": true}}
@@ -31,14 +20,20 @@
 {"collections": ["job"], "fields": {"id": 1, "studyUid": 1}, "options": {"unique": true}}
 {"collections": ["job"], "fields": {"tool.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"tool.type": 1, "studyUid": 1}, "options": {}}
+{"collections": ["job"], "fields": {"tool.externalExecutor.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"userId": 1, "studyUid": 1}, "options": {}}
+{"collections": ["job"], "fields": {"parentId": 1, "studyUid": 1}, "options": {}}
+{"collections": ["job"], "fields": {"dependsOn.id": 1, "studyUid": 1}, "options": {}}
+{"collections": ["job"], "fields": {"outDir.uid": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"input.uid": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"output.uid": 1, "studyUid": 1}, "options": {}}
-{"collections": ["job"], "fields": {"outDir.uid": 1, "studyUid": 1}, "options": {}}
+{"collections": ["job"], "fields": {"priority": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"tags": 1, "studyUid": 1}, "options": {}}
+{"collections": ["job"], "fields": {"dryRun: 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"visited": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"internal.status.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"internal.status.id": 1, "_priority": 1, "_creationDate": 1}, "options": {}}
+{"collections": ["job"], "fields": {"internal.killJobRequested": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"_priority": 1, "_creationDate": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"_priority": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"_creationDate": 1, "studyUid": 1}, "options": {}}
@@ -261,14 +256,26 @@
 {"collections": ["audit"], "fields": {"status.name": 1, "studyUuid": 1}, "options": {}}
 {"collections": ["audit"], "fields": {"date": 1, "studyUuid": 1}, "options": {}}
 
+{"collections": ["note", "note_archive"], "fields": {"id": 1, "studyUid": 1, "version": 1}, "options": {"unique": true}}
+{"collections": ["note", "note_archive"], "fields": {"uid": 1, "version": 1}, "options": {"unique": true}}
+{"collections": ["note", "note_archive"], "fields": {"uuid": 1, "version": 1}, "options": {"unique": true}}
+{"collections": ["note", "note_archive"], "fields": {"scope": 1, "studyUid": 1}, "options": {}}
+{"collections": ["note", "note_archive"], "fields": {"studyUid": 1}, "options": {}}
+{"collections": ["note", "note_archive"], "fields": {"visibility": 1, "studyUid": 1}, "options": {}}
+{"collections": ["note", "note_archive"], "fields": {"userId": 1, "studyUid": 1}, "options": {}}
+{"collections": ["note", "note_archive"], "fields": {"tags": 1, "studyUid": 1}, "options": {}}
+{"collections": ["note", "note_archive"], "fields": {"_creationDate": 1, "studyUid": 1}, "options": {}}
+{"collections": ["note", "note_archive"], "fields": {"_modificationDate": 1, "studyUid": 1}, "options": {}}
+
 {"collections": ["workflow", "workflow_archive"], "fields": {"uid": 1, "version": 1}, "options": {"unique": true}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"id": 1, "studyUid": 1, "version": 1}, "options": {"unique": true}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"uuid": 1, "version": 1}, "options": {"unique": true}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"name": 1, "studyUid": 1}, "options": {"unique": true}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"type": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"manager.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"tags": 1, "studyUid": 1}, "options": {}}
-{"collections": ["workflow", "workflow_archive"], "fields": {"scripts.fileName": 1, "studyUid": 1}, "options": {}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"draft": 1, "studyUid": 1}, "options": {}}
+{"collections": ["workflow", "workflow_archive"], "fields": {"scripts.fileName": 1, "studyUid": 1}, "options": {}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"internal.registrationUserId": 1, "studyUid": 1}, "options": {}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"_creationDate": 1, "studyUid": 1}, "options": {}}
 {"collections": ["workflow", "workflow_archive"], "fields": {"_modificationDate": 1, "studyUid": 1}, "options": {}}
diff --git a/opencga-client/src/main/javascript/Workflow.js b/opencga-client/src/main/javascript/Workflow.js
index 217d12f0826..f2dfd10cdf9 100644
--- a/opencga-client/src/main/javascript/Workflow.js
+++ b/opencga-client/src/main/javascript/Workflow.js
@@ -59,7 +59,7 @@ export default class Workflow extends OpenCGAParentClass {
     create(data, params) {
         return this._post("workflows", null, null, null, "create", data, params);
     }
-#
+
     /** Workflow distinct method
     * @param {String} field - Comma separated list of fields for which to obtain the distinct values.
     * @param {Object} [params] - The Object containing the following optional parameters:
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/Job.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/Job.java
index 802f5967f2f..4a1e688c724 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/Job.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/Job.java
@@ -28,150 +28,91 @@
 import java.util.List;
 import java.util.Map;
 
-/**
- * Created by jacobo on 11/09/14.
- */
-@DataClass(id = "Job", since = "1.0",
-        description = "Job data model hosts information about any job.")
+
+@DataClass(id = "Job", since = "1.0.0", description = "Job data model hosts information about any job.")
 public class Job extends PrivateStudyUid {
 
     public static final String OPENCGA_PARENTS = "OPENCGA_PARENTS";
-    /**
-     * Job ID is a mandatory parameter when creating a new sample, this ID cannot be changed at the moment.
-     *
-     * @apiNote Required, Immutable, Unique
-     */
+
     @DataField(id = "id", required = true, indexed = true, unique = true, immutable = true,
             description = FieldConstants.GENERIC_ID_DESCRIPTION)
     private String id;
-    /**
-     * Global unique ID at the whole OpenCGA installation. This is automatically created during the sample creation and cannot be changed.
-     *
-     * @apiNote Internal, Unique, Immutable
-     */
 
     @DataField(id = "uuid", managed = true, indexed = true, unique = true, immutable = true,
             description = FieldConstants.GENERIC_UUID_DESCRIPTION)
     private String uuid;
-    /**
-     * An string to describe the properties of the Job.
-     *
-     * @apiNote
-     */
-    @DataField(id = "description", defaultValue = "No description available",
-            description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
+
+    @DataField(id = "description", defaultValue = "", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
-    @DataField(id = "tool", indexed = true,
-            description = FieldConstants.JOB_TOOL)
+    @DataField(id = "tool", indexed = true, description = FieldConstants.JOB_TOOL)
     private ToolInfo tool;
 
-    @DataField(id = "userId", indexed = true,
-            description = FieldConstants.JOB_USER_ID)
+    @DataField(id = "study", indexed = true, description = FieldConstants.JOB_STUDY)
+    private JobStudyParam study;
+
+    @DataField(id = "userId", indexed = true, description = FieldConstants.JOB_USER_ID)
     private String userId;
 
-    @DataField(id = "commandLine", indexed = true,
-            description = FieldConstants.JOB_COMMAND_LINE)
+    @DataField(id = "commandLine", indexed = true, description = FieldConstants.JOB_COMMAND_LINE)
     private String commandLine;
 
-    @DataField(id = "params", indexed = true,
-            description = FieldConstants.JOB_PARAMS)
+    @DataField(id = "params", indexed = true, description = FieldConstants.JOB_PARAMS)
     private Map<String, Object> params;
-    /**
-     * String representing when the Cohort was created, this is automatically set by OpenCGA.
-     *
-     * @apiNote Internal
-     */
-    @DataField(id = "creationDate", indexed = true,
-            description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
+
+    @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
-    /**
-     * String representing when was the last time the Cohort was modified, this is automatically set by OpenCGA.
-     *
-     * @apiNote Internal
-     */
-    @DataField(id = "modificationDate", indexed = true, since = "1.0",
-            description = FieldConstants.GENERIC_MODIFICATION_DATE_DESCRIPTION)
-    private String modificationDate;
 
+    @DataField(id = "modificationDate", indexed = true, since = "1.0", description = FieldConstants.GENERIC_MODIFICATION_DATE_DESCRIPTION)
+    private String modificationDate;
 
-    @DataField(id = "priority", indexed = true,
-            description = FieldConstants.JOB_PRIORITY_DESCRIPTION)
+    @DataField(id = "priority", indexed = true, description = FieldConstants.JOB_PRIORITY_DESCRIPTION)
     private Enums.Priority priority;
 
-    /**
-     * An object describing the internal information of the Sample. This is managed by OpenCGA.
-     *
-     * @apiNote Internal
-     */
-
-    @DataField(id = "release", indexed = true,
-            description = FieldConstants.GENERIC_RELEASE_DESCRIPTION)
+    @DataField(id = "release", indexed = true, description = FieldConstants.GENERIC_RELEASE_DESCRIPTION)
     private JobInternal internal;
 
-    @DataField(id = "outDir", indexed = true,
-            description = FieldConstants.JOB_OUT_DIR_DESCRIPTION)
+    @DataField(id = "outDir", indexed = true, description = FieldConstants.JOB_OUT_DIR_DESCRIPTION)
     private File outDir;
 
-    @DataField(id = "input", indexed = true,
-            description = FieldConstants.JOB_INPUT_DESCRIPTION)
-    private List<File> input;    // input files to this job
+    @DataField(id = "input", indexed = true, description = FieldConstants.JOB_INPUT_DESCRIPTION)
+    private List<File> input;
 
-    @DataField(id = "output", indexed = true,
-            description = FieldConstants.JOB_OUTPUT_DESCRIPTION)
-    private List<File> output;   // output files of this job
+    @DataField(id = "output", indexed = true, description = FieldConstants.JOB_OUTPUT_DESCRIPTION)
+    private List<File> output;
 
-    @DataField(id = "tags", indexed = true,
-            description = FieldConstants.JOB_TAGS_DESCRIPTION)
+    @DataField(id = "tags", indexed = true, description = FieldConstants.JOB_TAGS_DESCRIPTION)
     private List<String> tags;
 
-    @DataField(id = "dependsOn", indexed = true,
-            description = FieldConstants.JOB_DEPENDS_ON_DESCRIPTION)
+    @DataField(id = "dependsOn", indexed = true, description = FieldConstants.JOB_DEPENDS_ON_DESCRIPTION)
     private List<Job> dependsOn;
 
-    @DataField(id = FieldConstants.JOB_PARENT_ID, indexed = false, since = "3.2.0",
-            description = FieldConstants.JOB_PARENT_ID_DESCRIPTION)
+    @DataField(id = FieldConstants.JOB_PARENT_ID, indexed = true, since = "3.2.0", description = FieldConstants.JOB_PARENT_ID_DESCRIPTION)
     private String parentId;
 
-    @DataField(id = FieldConstants.JOB_SCHEDULED_START_TIME, indexed = false, since = "3.2.0",
+    @DataField(id = FieldConstants.JOB_SCHEDULED_START_TIME, since = "3.2.0",
             description = FieldConstants.JOB_SCHEDULED_START_TIME_DESCRIPTION)
     private String scheduledStartTime;
 
     @DataField(id = ParamConstants.JOB_DRY_RUN, since = "3.2.0", description = ParamConstants.JOB_DRY_RUN_DESCRIPTION)
     private boolean dryRun;
 
-    @DataField(id = "execution", indexed = true,
-            description = FieldConstants.JOB_EXECUTION_DESCRIPTION)
+    @DataField(id = "execution", indexed = true, description = FieldConstants.JOB_EXECUTION_DESCRIPTION)
     private ExecutionResult execution;
 
-    @DataField(id = "stdout", indexed = true,
-            description = FieldConstants.JOB_STDOUT_DESCRIPTION)
+    @DataField(id = "stdout", indexed = true, description = FieldConstants.JOB_STDOUT_DESCRIPTION)
     private File stdout;
 
-    @DataField(id = "stderr", indexed = true,
-            description = FieldConstants.JOB_STDERR_DESCRIPTION)
+    @DataField(id = "stderr", indexed = true, description = FieldConstants.JOB_STDERR_DESCRIPTION)
     private File stderr;
 
-
-    @DataField(id = "visited", indexed = true,
-            description = FieldConstants.JOB_VISITED)
+    @DataField(id = "visited", indexed = true, description = FieldConstants.JOB_VISITED)
     private boolean visited;
-    /**
-     * An integer describing the current data release.
-     *
-     * @apiNote Internal
-     */
-
-    @DataField(id = "release", indexed = true,
-            description = FieldConstants.GENERIC_RELEASE_DESCRIPTION)
-    private int release;
 
-    @DataField(id = "study", indexed = true,
-            description = FieldConstants.JOB_STUDY)
-    private JobStudyParam study;
+    @DataField(id = "release", indexed = true, description = FieldConstants.GENERIC_RELEASE_DESCRIPTION)
+    private int release;
 
-    @DataField(id = "attributes", indexed = true,
-            description = FieldConstants.GENERIC_ATTRIBUTES_DESCRIPTION)
+    @DataField(id = "attributes", indexed = true, description = FieldConstants.GENERIC_ATTRIBUTES_DESCRIPTION)
     private Map<String, Object> attributes;
 
     public Job() {
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobInternal.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobInternal.java
index 123dc8bf70e..a74d34f3763 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobInternal.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobInternal.java
@@ -29,17 +29,14 @@
 
 public class JobInternal extends Internal implements Cloneable {
 
-    @DataField(id = "status", indexed = true,
-            description = FieldConstants.JOB_INTERNAL_STATUS_DESCRIPTION)
+    @DataField(id = "status", indexed = true, description = FieldConstants.JOB_INTERNAL_STATUS_DESCRIPTION)
     private Enums.ExecutionStatus status;
 
-    @DataField(id = "webhook", indexed = true,
-            description = FieldConstants.JOB_INTERNAL_WEBHOOK_DESCRIPTION)
+    @DataField(id = "webhook", indexed = true, description = FieldConstants.JOB_INTERNAL_WEBHOOK_DESCRIPTION)
     private JobInternalWebhook webhook;
 
     //TODO add tags to commons-datastore-core
-    @DataField(id = "events", indexed = true, uncommentedClasses = {"Event"},
-            description = FieldConstants.JOB_INTERNAL_EVENTS_DESCRIPTION)
+    @DataField(id = "events", indexed = true, uncommentedClasses = {"Event"}, description = FieldConstants.JOB_INTERNAL_EVENTS_DESCRIPTION)
     private List<Event> events;
 
     @DataField(id = "killJobRequested", indexed = false, since = "3.2.0",
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
index 81db952fcfb..78c132dd18d 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
@@ -41,7 +41,7 @@ public class ToolInfo {
     @DataField(id = "resource", description = FieldConstants.TOOL_INFO_RESOURCE_DESCRIPTION)
     private Enums.Resource resource;
 
-    @DataField(id = "resource", description = FieldConstants.TOOL_INFO_EXTERNAL_EXECUTOR_DESCRIPTION)
+    @DataField(id = "externalExecutor", since = "3.3.0", description = FieldConstants.TOOL_INFO_EXTERNAL_EXECUTOR_DESCRIPTION)
     private ToolInfoExecutor externalExecutor;
 
 
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index 8b81d614129..1d3768fa49a 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -1,5 +1,6 @@
 package org.opencb.opencga.core.models.workflow;
 
+import org.opencb.commons.annotations.DataClass;
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
 import org.opencb.opencga.core.models.PrivateStudyUid;
@@ -8,6 +9,7 @@
 import java.util.List;
 import java.util.Map;
 
+@DataClass(id = "Workflow", since = "3.3.0", description = "Job data model hosts information about any job.")
 public class Workflow extends PrivateStudyUid {
 
     @DataField(id = "id", required = true, indexed = true, unique = true, immutable = true,
@@ -24,27 +26,12 @@ public class Workflow extends PrivateStudyUid {
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
-    @DataField(id = "draft", description = FieldConstants.WORKFLOW_DRAFT_DESCRIPTION)
-    private boolean draft;
-
-    @DataField(id = "version", managed = true, indexed = true, description = FieldConstants.GENERIC_VERSION_DESCRIPTION)
-    private int version;
-
-    @DataField(id = "release", managed = true, indexed = true, description = FieldConstants.GENERIC_RELEASE_DESCRIPTION)
-    private int release;
-
     @DataField(id = "type", description = FieldConstants.WORKFLOW_TYPE_DESCRIPTION)
     private Type type;
 
     @DataField(id = "manager", description = FieldConstants.WORKFLOW_MANAGER_DESCRIPTION)
     private WorkflowSystem manager;
 
-    @DataField(id = "repository", description = FieldConstants.WORKFLOW_REPOSITORY_DESCRIPTION)
-    private WorkflowRepository repository;
-
-    @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
-    private List<WorkflowScript> scripts;
-
     @DataField(id = "tags", description = FieldConstants.WORKFLOW_TAGS_DESCRIPTION)
     private List<String> tags;
 
@@ -54,6 +41,21 @@ public class Workflow extends PrivateStudyUid {
     @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
     private WorkflowMinimumRequirements minimumRequirements;
 
+    @DataField(id = "draft", description = FieldConstants.WORKFLOW_DRAFT_DESCRIPTION)
+    private boolean draft;
+
+    @DataField(id = "repository", description = FieldConstants.WORKFLOW_REPOSITORY_DESCRIPTION)
+    private WorkflowRepository repository;
+
+    @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
+    private List<WorkflowScript> scripts;
+
+    @DataField(id = "version", managed = true, indexed = true, description = FieldConstants.GENERIC_VERSION_DESCRIPTION)
+    private int version;
+
+    @DataField(id = "release", managed = true, indexed = true, description = FieldConstants.GENERIC_RELEASE_DESCRIPTION)
+    private int release;
+
     @DataField(id = "internal", description = FieldConstants.WORKFLOW_INTERNAL_DESCRIPTION)
     private WorkflowInternal internal;
 
@@ -67,18 +69,18 @@ public class Workflow extends PrivateStudyUid {
     private Map<String, Object> attributes;
 
     public enum Type {
-        CLINICAL_INTERPRETATION,
         SECONDARY_ANALYSIS,
         RESEARCH_ANALYSIS,
+        CLINICAL_INTERPRETATION_ANALYSIS,
         OTHER
     }
 
     public Workflow() {
     }
 
-    public Workflow(String id, String name, String description, boolean draft, Type type, WorkflowSystem manager,
-                    WorkflowRepository repository, List<WorkflowScript> scripts, List<String> tags, List<Variable> variables,
-                    WorkflowMinimumRequirements minimumRequirements, WorkflowInternal internal, String creationDate,
+    public Workflow(String id, String name, String description, Type type, WorkflowSystem manager, List<String> tags,
+                    List<Variable> variables, WorkflowMinimumRequirements minimumRequirements, boolean draft,
+                    WorkflowRepository repository, List<WorkflowScript> scripts, WorkflowInternal internal, String creationDate,
                     String modificationDate, Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
@@ -104,16 +106,16 @@ public String toString() {
         sb.append(", uuid='").append(uuid).append('\'');
         sb.append(", name='").append(name).append('\'');
         sb.append(", description='").append(description).append('\'');
-        sb.append(", draft=").append(draft);
-        sb.append(", version=").append(version);
-        sb.append(", release=").append(release);
         sb.append(", type=").append(type);
         sb.append(", manager=").append(manager);
-        sb.append(", repository=").append(repository);
-        sb.append(", scripts=").append(scripts);
         sb.append(", tags=").append(tags);
         sb.append(", variables=").append(variables);
         sb.append(", minimumRequirements=").append(minimumRequirements);
+        sb.append(", draft=").append(draft);
+        sb.append(", repository=").append(repository);
+        sb.append(", scripts=").append(scripts);
+        sb.append(", version=").append(version);
+        sb.append(", release=").append(release);
         sb.append(", internal=").append(internal);
         sb.append(", creationDate='").append(creationDate).append('\'');
         sb.append(", modificationDate='").append(modificationDate).append('\'');
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
index 9e59feccc04..3241be4c896 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -97,7 +97,7 @@ public String toString() {
     }
 
     public Workflow toWorkflow() {
-        return new Workflow(id, name, description, draft, type, manager, repository, scripts, tags, variables, minimumRequirements,
+        return new Workflow(id, name, description, type, manager, tags, variables, minimumRequirements, draft, repository, scripts,
                 new WorkflowInternal(), creationDate, modificationDate, attributes);
     }
 

From 0c6bbf90e949d46c46214a2f2f554c88768b4637 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sun, 22 Sep 2024 19:25:54 +0100
Subject: [PATCH 37/99] docker: add 'make' command to custom-tool docker
 builder

---
 .../custom-tool-docker-build.py               | 47 +++++++------------
 1 file changed, 17 insertions(+), 30 deletions(-)

diff --git a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
index 66e291e0f8e..d0f3700e955 100755
--- a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
+++ b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
@@ -16,10 +16,7 @@
 parser.add_argument("-l", "--latest", help="Make the docker image latest, e.g. v1.0.0", default="False")
 parser.add_argument("-u", "--username", help="Username to login to the docker registry")
 parser.add_argument("-p", "--password", help="Password to login to the docker registry",)
-# parser.add_argument('--docker-build-args',
-#                     help="Additional build arguments to pass to the docker build command. Usage: --docker-build-args='ARGS' e.g: --docker-build-args='--no-cache'",
-#                     default="")
-parser.add_argument('--server', help="Docker registry server", default="docker.io")
+# parser.add_argument('--server', help="Docker registry server", default="docker.io")
 
 ## Some ANSI colors to print shell output
 shell_colors = {
@@ -31,25 +28,21 @@
     'reset': '\033[0m'
 }
 
-
 def error(message):
     sys.stderr.write(shell_colors['red'] + 'ERROR: %s\n' % message + shell_colors['reset'])
     sys.exit(2)
 
-
 def print_header(str):
     print(shell_colors['magenta'] + "*************************************************" + shell_colors['reset'])
     print(shell_colors['magenta'] + str + shell_colors['reset'])
     print(shell_colors['magenta'] + "*************************************************" + shell_colors['reset'])
 
-
 def run(command):
     print(shell_colors['bold'] + command + shell_colors['reset'])
     code = os.system(command)
     if code != 0:
         error("Error executing: " + command)
 
-
 def login(loginRequired=False):
     if args.username is None or args.password is None:
         if loginRequired:
@@ -72,35 +65,41 @@ def get_docker_image_id():
 
 
 def dockerfile():
-    # print_header('Creating Dockerfile ...')
     print(shell_colors['blue'] + "Creating Dockerfile  ..." + shell_colors['reset'])
 
     with open(custom_build_folder + "/Dockerfile", "w") as f:
+        ## Set base image and copy the custom tool folder
         f.write("FROM ubuntu:24.04\n\n")
         f.write("COPY . /opt/app\n\n")
 
-        # Update Ubuntu and install base libraries
+        ## Install Ubuntu OS dependencies with 'apt'
+        # 1. Update Ubuntu and install base libraries
         f.write("RUN apt update && apt -y upgrade && apt install -y python3 python3-pip && \\ \n")
 
-        # Install R
+        # 2. Install R
         if args.install_r is True:
             f.write("apt install -y r-base && \\ \n")
 
-        # Install user's apt dependencies
+        # 3. Install user's apt dependencies
         if args.apt_get is not None and not args.apt_get == "":
             f.write("apt install -y " + args.apt_get.replace(",", " ") + " && \\ \n")
 
-        # Install Python dependencies
+        # 4. Check and build C/C++ tools
+        if os.path.isfile(custom_build_folder + "/makefile") or os.path.isfile(custom_build_folder + "/Makefile"):
+            f.write("apt install -y build-essential && \\ \n")
+            f.write("make -C /opt/app && \\ \n")
+
+        ## Install application dependencies, only Python and R supported
+        # 1. Install Python dependencies
         if os.path.isfile(custom_build_folder + "/requirements.txt"):
             f.write("pip3 install -r /opt/app/requirements.txt --break-system-packages && \\ \n")
 
-        # Install R dependencies
+        # 2. Install R dependencies
         if args.install_r is True and os.path.isfile(custom_build_folder + "/install.r"):
             f.write("Rscript /opt/app/install.r && \\ \n")
 
+        ## Clean up and set working directory
         f.write("rm -rf /var/lib/apt/lists/* \n\n")
-
-        # f.write("USER opencga\n\n")
         f.write("WORKDIR /opt/app\n\n")
         f.write("CMD bash\n")
 
@@ -116,9 +115,6 @@ def build():
     run(command)
 
 def tag_latest(image):
-    # if server:
-    #     print("Don't use tag latest in server " + server)
-    #     return
     latest_tag = os.popen(("curl -s https://registry.hub.docker.com/v1/repositories/" + args.organisation + "/" + args.name + "/tags"
                            + " | jq -r .[].name"
                            + " | grep -v latest"
@@ -137,9 +133,6 @@ def push():
     image = get_docker_image_id()
     print(shell_colors['blue'] + "Pushing to Docker Hub image: " + image + shell_colors['reset'])
 
-    # if server:
-    #     run("docker tag " + image + ":" + tag + " " + server + image + ":" + tag)
-    # run("docker push " + server + image + ":" + tag)
     run("docker push " + image)
     if args.latest == True:
         tag_latest(image)
@@ -151,7 +144,7 @@ def push():
 # 1. Set build folder to default value if not set
 if args.custom_tool_dir is not None and not args.custom_tool_dir == "":
     if args.custom_tool_dir.startswith("git@"):
-        custom_build_folder = "/tmp/custom-tool"
+        custom_build_folder = "/tmp/opencga-custom-tool"
         os.system("rm -rf " + custom_build_folder)
         os.system("git clone " + args.custom_tool_dir + " " + custom_build_folder)
     else:
@@ -162,13 +155,7 @@ def push():
 else:
     error("Custom tool folder is required")
 
-# 2. Set docker server
-# if args.server != "docker.io":
-#     server = args.server + "/"
-# else:
-#     server = ""
-
-## Execute the action
+## 2. Execute the action
 if args.action == "dockerfile":
     dockerfile()
 elif args.action == "build":

From 88ac8ba429a3b7c2a2a132c9496a1adeaffeedf6 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sun, 22 Sep 2024 20:39:07 +0100
Subject: [PATCH 38/99] rest: rename 'job/run' web service

---
 .../main/java/org/opencb/opencga/server/rest/JobWSServer.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
index 7f20f7ae8f7..b1e02be8127 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
@@ -124,7 +124,7 @@ public Response kill(
     @Path("/run")
     @Consumes(MediaType.APPLICATION_JSON)
     @ApiOperation(value = BinaryExecutor.DESCRIPTION, response = Job.class)
-    public Response updateByPost(
+    public Response runByPost(
             @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String study,
             @ApiParam(value = ParamConstants.JOB_ID_CREATION_DESCRIPTION) @QueryParam(ParamConstants.JOB_ID) String jobName,
             @ApiParam(value = ParamConstants.JOB_DESCRIPTION_DESCRIPTION) @QueryParam(ParamConstants.JOB_DESCRIPTION) String jobDescription,
@@ -309,7 +309,7 @@ public Response distinct(
             @ApiImplicitParam(name = QueryOptions.EXCLUDE, value = ParamConstants.EXCLUDE_DESCRIPTION,
                     dataType = "string", paramType = "query")
     })
-    public Response updateByPost(
+    public Response runByPost(
             @ApiParam(value = ParamConstants.JOBS_DESCRIPTION, required = true) @PathParam("jobs") String jobStr,
             @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
             @ApiParam(value = ParamConstants.INCLUDE_RESULT_DESCRIPTION, defaultValue = "false") @QueryParam(ParamConstants.INCLUDE_RESULT_PARAM) boolean includeResult,

From 661241afd7d4535b0919090c0944525501bdbdd8 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sun, 22 Sep 2024 20:53:42 +0100
Subject: [PATCH 39/99] Add new REST web service to build tools for customer,
 new path for tools is 'job/tool/{run|build}

---
 .../app/cli/main/OpenCgaCompleter.java        |  2 +-
 .../app/cli/main/OpencgaCliOptionsParser.java |  1 +
 .../main/executors/JobsCommandExecutor.java   | 51 ++++++++++++
 .../cli/main/options/JobsCommandOptions.java  | 64 +++++++++++++++
 opencga-client/src/main/R/R/Job-methods.R     | 15 ++++
 .../client/rest/clients/JobClient.java        | 23 ++++++
 opencga-client/src/main/javascript/Job.js     | 19 +++++
 .../pyopencga/rest_clients/job_client.py      | 25 ++++++
 .../models/job/JobToolBuildDockerParams.java  | 80 +++++++++++++++++++
 .../core/models/job/JobToolBuildParams.java   | 68 ++++++++++++++++
 .../opencga/server/rest/JobWSServer.java      | 16 ++++
 11 files changed, 363 insertions(+), 1 deletion(-)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobToolBuildDockerParams.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobToolBuildParams.java

diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
index d3da3e09871..ea6da492b81 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
@@ -49,7 +49,7 @@ public abstract class OpenCgaCompleter implements Completer {
             .map(Candidate::new)
             .collect(toList());
 
-    private List<Candidate> jobsList = asList( "acl-update","create","distinct","retry","run","search","top","acl","delete","info","update","kill","log-head","log-tail")
+    private List<Candidate> jobsList = asList( "acl-update","create","distinct","retry","run","search","tool-build","top","acl","delete","info","update","kill","log-head","log-tail")
             .stream()
             .map(Candidate::new)
             .collect(toList());
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
index 16376431714..52d281f1eea 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
@@ -156,6 +156,7 @@ public OpencgaCliOptionsParser() {
         jobsSubCommands.addCommand("retry", jobsCommandOptions.retryCommandOptions);
         jobsSubCommands.addCommand("run", jobsCommandOptions.runCommandOptions);
         jobsSubCommands.addCommand("search", jobsCommandOptions.searchCommandOptions);
+        jobsSubCommands.addCommand("tool-build", jobsCommandOptions.buildToolCommandOptions);
         jobsSubCommands.addCommand("top", jobsCommandOptions.topCommandOptions);
         jobsSubCommands.addCommand("acl", jobsCommandOptions.aclCommandOptions);
         jobsSubCommands.addCommand("delete", jobsCommandOptions.deleteCommandOptions);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
index ba48c6db8f9..28d24ee5c59 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
@@ -26,6 +26,8 @@
 import org.opencb.opencga.core.models.job.JobRunDockerParams;
 import org.opencb.opencga.core.models.job.JobRunGitParams;
 import org.opencb.opencga.core.models.job.JobRunParams;
+import org.opencb.opencga.core.models.job.JobToolBuildDockerParams;
+import org.opencb.opencga.core.models.job.JobToolBuildParams;
 import org.opencb.opencga.core.models.job.JobTop;
 import org.opencb.opencga.core.models.job.JobUpdateParams;
 import org.opencb.opencga.core.models.job.ToolInfo;
@@ -89,6 +91,9 @@ public void execute() throws Exception {
             case "search":
                 queryResponse = search();
                 break;
+            case "tool-build":
+                queryResponse = buildTool();
+                break;
             case "top":
                 queryResponse = top();
                 break;
@@ -356,6 +361,52 @@ private RestResponse<Job> search() throws Exception {
         return openCGAClient.getJobClient().search(queryParams);
     }
 
+    private RestResponse<Job> buildTool() throws Exception {
+        logger.debug("Executing buildTool in Jobs command line");
+
+        JobsCommandOptions.BuildToolCommandOptions commandOptions = jobsCommandOptions.buildToolCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("jobId", commandOptions.jobId);
+        queryParams.putIfNotEmpty("jobDescription", commandOptions.jobDescription);
+        queryParams.putIfNotEmpty("jobDependsOn", commandOptions.jobDependsOn);
+        queryParams.putIfNotEmpty("jobTags", commandOptions.jobTags);
+        queryParams.putIfNotEmpty("jobScheduledStartTime", commandOptions.jobScheduledStartTime);
+        queryParams.putIfNotEmpty("jobPriority", commandOptions.jobPriority);
+        queryParams.putIfNotNull("jobDryRun", commandOptions.jobDryRun);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        JobToolBuildParams jobToolBuildParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<Job> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/jobs/tool/build"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            jobToolBuildParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), JobToolBuildParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotEmpty(beanParams, "gitRepository",commandOptions.gitRepository, true);
+            putNestedIfNotEmpty(beanParams, "aptGet",commandOptions.aptGet, true);
+            putNestedIfNotNull(beanParams, "installR",commandOptions.installR, true);
+            putNestedIfNotEmpty(beanParams, "docker.organisation",commandOptions.dockerOrganisation, true);
+            putNestedIfNotEmpty(beanParams, "docker.name",commandOptions.dockerName, true);
+            putNestedIfNotEmpty(beanParams, "docker.tag",commandOptions.dockerTag, true);
+            putNestedIfNotEmpty(beanParams, "docker.user",commandOptions.dockerUser, true);
+            putNestedIfNotEmpty(beanParams, "docker.password",commandOptions.dockerPassword, true);
+
+            jobToolBuildParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), JobToolBuildParams.class);
+        }
+        return openCGAClient.getJobClient().buildTool(jobToolBuildParams, queryParams);
+    }
+
     private RestResponse<JobTop> top() throws Exception {
         logger.debug("Executing top in Jobs command line");
 
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
index 2dc71a214e3..164b268af40 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
@@ -39,6 +39,7 @@ public class JobsCommandOptions extends CustomJobsCommandOptions {
         public RetryCommandOptions retryCommandOptions;
         public RunCommandOptions runCommandOptions;
         public SearchCommandOptions searchCommandOptions;
+        public BuildToolCommandOptions buildToolCommandOptions;
         public TopCommandOptions topCommandOptions;
         public AclCommandOptions aclCommandOptions;
         public DeleteCommandOptions deleteCommandOptions;
@@ -58,6 +59,7 @@ public JobsCommandOptions(CommonCommandOptions commonCommandOptions, JCommander
         this.retryCommandOptions = new RetryCommandOptions();
         this.runCommandOptions = new RunCommandOptions();
         this.searchCommandOptions = new SearchCommandOptions();
+        this.buildToolCommandOptions = new BuildToolCommandOptions();
         this.topCommandOptions = new TopCommandOptions();
         this.aclCommandOptions = new AclCommandOptions();
         this.deleteCommandOptions = new DeleteCommandOptions();
@@ -414,6 +416,68 @@ public class SearchCommandOptions {
     
     }
 
+    @Parameters(commandNames = {"tool-build"}, commandDescription ="Execute an analysis from a custom binary.")
+    public class BuildToolCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--job-id"}, description = "Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.", required = false, arity = 1)
+        public String jobId; 
+    
+        @Parameter(names = {"--job-description"}, description = "Job description", required = false, arity = 1)
+        public String jobDescription; 
+    
+        @Parameter(names = {"--job-depends-on"}, description = "Comma separated list of existing job IDs the job will depend on.", required = false, arity = 1)
+        public String jobDependsOn; 
+    
+        @Parameter(names = {"--job-tags"}, description = "Job tags", required = false, arity = 1)
+        public String jobTags; 
+    
+        @Parameter(names = {"--job-scheduled-start-time"}, description = "Time when the job is scheduled to start.", required = false, arity = 1)
+        public String jobScheduledStartTime; 
+    
+        @Parameter(names = {"--job-priority"}, description = "Priority of the job", required = false, arity = 1)
+        public String jobPriority; 
+    
+        @Parameter(names = {"--job-dry-run"}, description = "Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.", required = false, arity = 1)
+        public Boolean jobDryRun; 
+    
+        @Parameter(names = {"--git-repository"}, description = "The body web service gitRepository parameter", required = false, arity = 1)
+        public String gitRepository;
+    
+        @Parameter(names = {"--apt-get"}, description = "The body web service aptGet parameter", required = false, arity = 1)
+        public String aptGet;
+    
+        @Parameter(names = {"--install-r"}, description = "The body web service installR parameter", required = false, arity = 1)
+        public Boolean installR;
+    
+        @Parameter(names = {"--docker-organisation"}, description = "The body web service organisation parameter", required = false, arity = 1)
+        public String dockerOrganisation;
+    
+        @Parameter(names = {"--docker-name"}, description = "The body web service name parameter", required = false, arity = 1)
+        public String dockerName;
+    
+        @Parameter(names = {"--docker-tag"}, description = "The body web service tag parameter", required = false, arity = 1)
+        public String dockerTag;
+    
+        @Parameter(names = {"--docker-user"}, description = "The body web service user parameter", required = false, arity = 1)
+        public String dockerUser;
+    
+        @Parameter(names = {"--docker-password"}, description = "The body web service password parameter", required = false, arity = 1)
+        public String dockerPassword;
+    
+    }
+
     @Parameters(commandNames = {"acl"}, commandDescription ="Return the acl of the job. If member is provided, it will only return the acl for the member.")
     public class AclCommandOptions {
     
diff --git a/opencga-client/src/main/R/R/Job-methods.R b/opencga-client/src/main/R/R/Job-methods.R
index 48d4d12f2f5..7e492eefa3e 100644
--- a/opencga-client/src/main/R/R/Job-methods.R
+++ b/opencga-client/src/main/R/R/Job-methods.R
@@ -25,6 +25,7 @@
 #' | retry | /{apiVersion}/jobs/retry | jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, study, body[*] |
 #' | run | /{apiVersion}/jobs/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | search | /{apiVersion}/jobs/search | include, exclude, limit, skip, count, study, otherStudies, id, uuid, toolId, toolType, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted |
+#' | buildTool | /{apiVersion}/jobs/tool/build | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | top | /{apiVersion}/jobs/top | limit, study, internalStatus, priority, userId, toolId |
 #' | acl | /{apiVersion}/jobs/{jobs}/acl | jobs[*], member, silent |
 #' | delete | /{apiVersion}/jobs/{jobs}/delete | study, jobs[*] |
@@ -139,6 +140,20 @@ setMethod("jobClient", "OpencgaR", function(OpencgaR, job, jobs, members, endpoi
         search=fetchOpenCGA(object=OpencgaR, category="jobs", categoryId=NULL, subcategory=NULL, subcategoryId=NULL,
                 action="search", params=params, httpMethod="GET", as.queryParam=NULL, ...),
 
+        #' @section Endpoint /{apiVersion}/jobs/tool/build:
+        #' Execute an analysis from a custom binary.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param jobId Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+        #' @param jobDescription Job description.
+        #' @param jobDependsOn Comma separated list of existing job IDs the job will depend on.
+        #' @param jobTags Job tags.
+        #' @param jobScheduledStartTime Time when the job is scheduled to start.
+        #' @param jobPriority Priority of the job.
+        #' @param jobDryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+        #' @param data NextFlow run parameters.
+        buildTool=fetchOpenCGA(object=OpencgaR, category="jobs", categoryId=NULL, subcategory="tool",
+                subcategoryId=NULL, action="build", params=params, httpMethod="POST", as.queryParam=NULL, ...),
+
         #' @section Endpoint /{apiVersion}/jobs/top:
         #' Provide a summary of the running jobs.
         #' @param limit Maximum number of jobs to be returned.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
index d2fbb967c6b..f81a5f3bff2 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
@@ -28,6 +28,7 @@
 import org.opencb.opencga.core.models.job.JobCreateParams;
 import org.opencb.opencga.core.models.job.JobRetryParams;
 import org.opencb.opencga.core.models.job.JobRunParams;
+import org.opencb.opencga.core.models.job.JobToolBuildParams;
 import org.opencb.opencga.core.models.job.JobTop;
 import org.opencb.opencga.core.models.job.JobUpdateParams;
 import org.opencb.opencga.core.response.RestResponse;
@@ -198,6 +199,28 @@ public RestResponse<Job> search(ObjectMap params) throws ClientException {
         return execute("jobs", null, null, null, "search", params, GET, Job.class);
     }
 
+    /**
+     * Execute an analysis from a custom binary.
+     * @param data NextFlow run parameters.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       jobId: Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+     *       jobDescription: Job description.
+     *       jobDependsOn: Comma separated list of existing job IDs the job will depend on.
+     *       jobTags: Job tags.
+     *       jobScheduledStartTime: Time when the job is scheduled to start.
+     *       jobPriority: Priority of the job.
+     *       jobDryRun: Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all
+     *            parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Job> buildTool(JobToolBuildParams data, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.put("body", data);
+        return execute("jobs", null, "tool", null, "build", params, POST, Job.class);
+    }
+
     /**
      * Provide a summary of the running jobs.
      * @param params Map containing any of the following optional parameters.
diff --git a/opencga-client/src/main/javascript/Job.js b/opencga-client/src/main/javascript/Job.js
index fbbe2f66421..b82d6f0e9e6 100644
--- a/opencga-client/src/main/javascript/Job.js
+++ b/opencga-client/src/main/javascript/Job.js
@@ -160,6 +160,25 @@ export default class Job extends OpenCGAParentClass {
         return this._get("jobs", null, null, null, "search", params);
     }
 
+    /** Execute an analysis from a custom binary.
+    * @param {Object} data - NextFlow run parameters.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {String} [params.jobId] - Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not
+    *     provided.
+    * @param {String} [params.jobDescription] - Job description.
+    * @param {String} [params.jobDependsOn] - Comma separated list of existing job IDs the job will depend on.
+    * @param {String} [params.jobTags] - Job tags.
+    * @param {String} [params.jobScheduledStartTime] - Time when the job is scheduled to start.
+    * @param {String} [params.jobPriority] - Priority of the job.
+    * @param {Boolean} [params.jobDryRun] - Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will
+    *     validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    buildTool(data, params) {
+        return this._post("jobs", null, "tool", null, "build", data, params);
+    }
+
     /** Provide a summary of the running jobs
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {Number} [params.limit = "20"] - Maximum number of jobs to be returned. The default value is 20.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
index bc9fd3d34b0..c28b9f264d0 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
@@ -191,6 +191,31 @@ def search(self, **options):
 
         return self._get(category='jobs', resource='search', **options)
 
+    def build_tool(self, data=None, **options):
+        """
+        Execute an analysis from a custom binary.
+        PATH: /{apiVersion}/jobs/tool/build
+
+        :param dict data: NextFlow run parameters. (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str job_id: Job ID. It must be a unique string within the
+            study. An ID will be autogenerated automatically if not provided.
+        :param str job_description: Job description.
+        :param str job_depends_on: Comma separated list of existing job IDs
+            the job will depend on.
+        :param str job_tags: Job tags.
+        :param str job_scheduled_start_time: Time when the job is scheduled to
+            start.
+        :param str job_priority: Priority of the job.
+        :param bool job_dry_run: Flag indicating that the job will be executed
+            in dry-run mode. In this mode, OpenCGA will validate that all
+            parameters and prerequisites are correctly set for successful
+            execution, but the job will not actually run.
+        """
+
+        return self._post(category='jobs', resource='build', subcategory='tool', data=data, **options)
+
     def top(self, **options):
         """
         Provide a summary of the running jobs.
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobToolBuildDockerParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobToolBuildDockerParams.java
new file mode 100644
index 00000000000..850755a742a
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobToolBuildDockerParams.java
@@ -0,0 +1,80 @@
+package org.opencb.opencga.core.models.job;
+
+import org.opencb.opencga.core.tools.ToolParams;
+
+public class JobToolBuildDockerParams extends ToolParams {
+
+    private String organisation;
+    private String name;
+    private String tag;
+    private String user;
+    private String password;
+
+    public JobToolBuildDockerParams() {
+    }
+
+    public JobToolBuildDockerParams(String organisation, String name, String tag, String user, String password) {
+        this.organisation = organisation;
+        this.name = name;
+        this.tag = tag;
+        this.user = user;
+        this.password = password;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("JobToolBuildDockerParams{");
+        sb.append("organisation='").append(organisation).append('\'');
+        sb.append(", name='").append(name).append('\'');
+        sb.append(", tag='").append(tag).append('\'');
+        sb.append(", user='").append(user).append('\'');
+        sb.append(", password='").append(password).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getOrganisation() {
+        return organisation;
+    }
+
+    public JobToolBuildDockerParams setOrganisation(String organisation) {
+        this.organisation = organisation;
+        return this;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public JobToolBuildDockerParams setName(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public String getTag() {
+        return tag;
+    }
+
+    public JobToolBuildDockerParams setTag(String tag) {
+        this.tag = tag;
+        return this;
+    }
+
+    public String getUser() {
+        return user;
+    }
+
+    public JobToolBuildDockerParams setUser(String user) {
+        this.user = user;
+        return this;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public JobToolBuildDockerParams setPassword(String password) {
+        this.password = password;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobToolBuildParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobToolBuildParams.java
new file mode 100644
index 00000000000..4994f5c3ee5
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobToolBuildParams.java
@@ -0,0 +1,68 @@
+package org.opencb.opencga.core.models.job;
+
+import org.opencb.opencga.core.tools.ToolParams;
+
+public class JobToolBuildParams extends ToolParams {
+
+    private String gitRepository;
+    private String aptGet;
+    private Boolean installR;
+    private JobToolBuildDockerParams docker;
+
+    public JobToolBuildParams() {
+    }
+
+    public JobToolBuildParams(String gitRepository, String aptGet, Boolean installR, JobToolBuildDockerParams docker) {
+        this.gitRepository = gitRepository;
+        this.aptGet = aptGet;
+        this.installR = installR;
+        this.docker = docker;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("JobToolBuildParams{");
+        sb.append("gitRepository='").append(gitRepository).append('\'');
+        sb.append(", aptGet='").append(aptGet).append('\'');
+        sb.append(", installR=").append(installR);
+        sb.append(", docker=").append(docker);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getGitRepository() {
+        return gitRepository;
+    }
+
+    public JobToolBuildParams setGitRepository(String gitRepository) {
+        this.gitRepository = gitRepository;
+        return this;
+    }
+
+    public String getAptGet() {
+        return aptGet;
+    }
+
+    public JobToolBuildParams setAptGet(String aptGet) {
+        this.aptGet = aptGet;
+        return this;
+    }
+
+    public Boolean getInstallR() {
+        return installR;
+    }
+
+    public JobToolBuildParams setInstallR(Boolean installR) {
+        this.installR = installR;
+        return this;
+    }
+
+    public JobToolBuildDockerParams getDocker() {
+        return docker;
+    }
+
+    public JobToolBuildParams setDocker(JobToolBuildDockerParams docker) {
+        this.docker = docker;
+        return this;
+    }
+}
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
index b1e02be8127..adecf6baee8 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
@@ -137,6 +137,22 @@ public Response runByPost(
         return submitJob(BinaryExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
+    @POST
+    @Path("/tool/build")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @ApiOperation(value = BinaryExecutor.DESCRIPTION, response = Job.class)
+    public Response dockerBuildByPost(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String study,
+            @ApiParam(value = ParamConstants.JOB_ID_CREATION_DESCRIPTION) @QueryParam(ParamConstants.JOB_ID) String jobName,
+            @ApiParam(value = ParamConstants.JOB_DESCRIPTION_DESCRIPTION) @QueryParam(ParamConstants.JOB_DESCRIPTION) String jobDescription,
+            @ApiParam(value = ParamConstants.JOB_DEPENDS_ON_DESCRIPTION) @QueryParam(JOB_DEPENDS_ON) String dependsOn,
+            @ApiParam(value = ParamConstants.JOB_TAGS_DESCRIPTION) @QueryParam(ParamConstants.JOB_TAGS) String jobTags,
+            @ApiParam(value = ParamConstants.JOB_SCHEDULED_START_TIME_DESCRIPTION) @QueryParam(ParamConstants.JOB_SCHEDULED_START_TIME) String scheduledStartTime,
+            @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
+            @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
+            @ApiParam(value = "body", required = true) JobToolBuildParams params) {
+        return submitJob(BinaryExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+    }
 
     @GET
     @Path("/{jobs}/info")

From f089a67f904541419dd72f67a1a9905b13fb8cce Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sun, 22 Sep 2024 20:56:24 +0100
Subject: [PATCH 40/99] rest: move 'job/run' to /job/tool/run'

---
 .../app/cli/main/OpenCgaCompleter.java        |   2 +-
 .../app/cli/main/OpencgaCliOptionsParser.java |   2 +-
 .../main/executors/JobsCommandExecutor.java   |  94 +++++++-------
 .../cli/main/options/JobsCommandOptions.java  | 116 +++++++++---------
 opencga-client/src/main/R/R/Job-methods.R     |  32 ++---
 .../client/rest/clients/JobClient.java        |  46 +++----
 opencga-client/src/main/javascript/Job.js     |  40 +++---
 .../pyopencga/rest_clients/job_client.py      |  52 ++++----
 .../opencga/server/rest/JobWSServer.java      |   2 +-
 9 files changed, 193 insertions(+), 193 deletions(-)

diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
index ea6da492b81..1393604cf5b 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
@@ -49,7 +49,7 @@ public abstract class OpenCgaCompleter implements Completer {
             .map(Candidate::new)
             .collect(toList());
 
-    private List<Candidate> jobsList = asList( "acl-update","create","distinct","retry","run","search","tool-build","top","acl","delete","info","update","kill","log-head","log-tail")
+    private List<Candidate> jobsList = asList( "acl-update","create","distinct","retry","search","tool-build","tool-run","top","acl","delete","info","update","kill","log-head","log-tail")
             .stream()
             .map(Candidate::new)
             .collect(toList());
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
index 52d281f1eea..7530fa78a32 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
@@ -154,9 +154,9 @@ public OpencgaCliOptionsParser() {
         jobsSubCommands.addCommand("create", jobsCommandOptions.createCommandOptions);
         jobsSubCommands.addCommand("distinct", jobsCommandOptions.distinctCommandOptions);
         jobsSubCommands.addCommand("retry", jobsCommandOptions.retryCommandOptions);
-        jobsSubCommands.addCommand("run", jobsCommandOptions.runCommandOptions);
         jobsSubCommands.addCommand("search", jobsCommandOptions.searchCommandOptions);
         jobsSubCommands.addCommand("tool-build", jobsCommandOptions.buildToolCommandOptions);
+        jobsSubCommands.addCommand("tool-run", jobsCommandOptions.runToolCommandOptions);
         jobsSubCommands.addCommand("top", jobsCommandOptions.topCommandOptions);
         jobsSubCommands.addCommand("acl", jobsCommandOptions.aclCommandOptions);
         jobsSubCommands.addCommand("delete", jobsCommandOptions.deleteCommandOptions);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
index 28d24ee5c59..ea9e2079b5d 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
@@ -85,15 +85,15 @@ public void execute() throws Exception {
             case "retry":
                 queryResponse = retry();
                 break;
-            case "run":
-                queryResponse = run();
-                break;
             case "search":
                 queryResponse = search();
                 break;
             case "tool-build":
                 queryResponse = buildTool();
                 break;
+            case "tool-run":
+                queryResponse = runTool();
+                break;
             case "top":
                 queryResponse = top();
                 break;
@@ -280,50 +280,6 @@ private RestResponse<Job> retry() throws Exception {
         return openCGAClient.getJobClient().retry(jobRetryParams, queryParams);
     }
 
-    private RestResponse<Job> run() throws Exception {
-        logger.debug("Executing run in Jobs command line");
-
-        JobsCommandOptions.RunCommandOptions commandOptions = jobsCommandOptions.runCommandOptions;
-
-        ObjectMap queryParams = new ObjectMap();
-        queryParams.putIfNotEmpty("study", commandOptions.study);
-        queryParams.putIfNotEmpty("jobId", commandOptions.jobId);
-        queryParams.putIfNotEmpty("jobDescription", commandOptions.jobDescription);
-        queryParams.putIfNotEmpty("jobDependsOn", commandOptions.jobDependsOn);
-        queryParams.putIfNotEmpty("jobTags", commandOptions.jobTags);
-        queryParams.putIfNotEmpty("jobScheduledStartTime", commandOptions.jobScheduledStartTime);
-        queryParams.putIfNotEmpty("jobPriority", commandOptions.jobPriority);
-        queryParams.putIfNotNull("jobDryRun", commandOptions.jobDryRun);
-        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
-            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
-        }
-
-
-        JobRunParams jobRunParams = null;
-        if (commandOptions.jsonDataModel) {
-            RestResponse<Job> res = new RestResponse<>();
-            res.setType(QueryType.VOID);
-            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/jobs/run"));
-            return res;
-        } else if (commandOptions.jsonFile != null) {
-            jobRunParams = JacksonUtils.getDefaultObjectMapper()
-                    .readValue(new java.io.File(commandOptions.jsonFile), JobRunParams.class);
-        } else {
-            ObjectMap beanParams = new ObjectMap();
-            putNestedIfNotEmpty(beanParams, "commandLine",commandOptions.commandLine, true);
-            putNestedIfNotEmpty(beanParams, "docker.id",commandOptions.dockerId, true);
-            putNestedIfNotEmpty(beanParams, "docker.tag",commandOptions.dockerTag, true);
-            putNestedIfNotEmpty(beanParams, "docker.token",commandOptions.dockerToken, true);
-            putNestedIfNotEmpty(beanParams, "git.repository",commandOptions.gitRepository, true);
-            putNestedIfNotEmpty(beanParams, "git.reference",commandOptions.gitReference, true);
-
-            jobRunParams = JacksonUtils.getDefaultObjectMapper().copy()
-                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
-                    .readValue(beanParams.toJson(), JobRunParams.class);
-        }
-        return openCGAClient.getJobClient().run(jobRunParams, queryParams);
-    }
-
     private RestResponse<Job> search() throws Exception {
         logger.debug("Executing search in Jobs command line");
 
@@ -407,6 +363,50 @@ private RestResponse<Job> buildTool() throws Exception {
         return openCGAClient.getJobClient().buildTool(jobToolBuildParams, queryParams);
     }
 
+    private RestResponse<Job> runTool() throws Exception {
+        logger.debug("Executing runTool in Jobs command line");
+
+        JobsCommandOptions.RunToolCommandOptions commandOptions = jobsCommandOptions.runToolCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("jobId", commandOptions.jobId);
+        queryParams.putIfNotEmpty("jobDescription", commandOptions.jobDescription);
+        queryParams.putIfNotEmpty("jobDependsOn", commandOptions.jobDependsOn);
+        queryParams.putIfNotEmpty("jobTags", commandOptions.jobTags);
+        queryParams.putIfNotEmpty("jobScheduledStartTime", commandOptions.jobScheduledStartTime);
+        queryParams.putIfNotEmpty("jobPriority", commandOptions.jobPriority);
+        queryParams.putIfNotNull("jobDryRun", commandOptions.jobDryRun);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        JobRunParams jobRunParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<Job> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/jobs/tool/run"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            jobRunParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), JobRunParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotEmpty(beanParams, "commandLine",commandOptions.commandLine, true);
+            putNestedIfNotEmpty(beanParams, "docker.id",commandOptions.dockerId, true);
+            putNestedIfNotEmpty(beanParams, "docker.tag",commandOptions.dockerTag, true);
+            putNestedIfNotEmpty(beanParams, "docker.token",commandOptions.dockerToken, true);
+            putNestedIfNotEmpty(beanParams, "git.repository",commandOptions.gitRepository, true);
+            putNestedIfNotEmpty(beanParams, "git.reference",commandOptions.gitReference, true);
+
+            jobRunParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), JobRunParams.class);
+        }
+        return openCGAClient.getJobClient().runTool(jobRunParams, queryParams);
+    }
+
     private RestResponse<JobTop> top() throws Exception {
         logger.debug("Executing top in Jobs command line");
 
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
index 164b268af40..b918e3ee137 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
@@ -37,9 +37,9 @@ public class JobsCommandOptions extends CustomJobsCommandOptions {
         public CreateCommandOptions createCommandOptions;
         public DistinctCommandOptions distinctCommandOptions;
         public RetryCommandOptions retryCommandOptions;
-        public RunCommandOptions runCommandOptions;
         public SearchCommandOptions searchCommandOptions;
         public BuildToolCommandOptions buildToolCommandOptions;
+        public RunToolCommandOptions runToolCommandOptions;
         public TopCommandOptions topCommandOptions;
         public AclCommandOptions aclCommandOptions;
         public DeleteCommandOptions deleteCommandOptions;
@@ -57,9 +57,9 @@ public JobsCommandOptions(CommonCommandOptions commonCommandOptions, JCommander
         this.createCommandOptions = new CreateCommandOptions();
         this.distinctCommandOptions = new DistinctCommandOptions();
         this.retryCommandOptions = new RetryCommandOptions();
-        this.runCommandOptions = new RunCommandOptions();
         this.searchCommandOptions = new SearchCommandOptions();
         this.buildToolCommandOptions = new BuildToolCommandOptions();
+        this.runToolCommandOptions = new RunToolCommandOptions();
         this.topCommandOptions = new TopCommandOptions();
         this.aclCommandOptions = new AclCommandOptions();
         this.deleteCommandOptions = new DeleteCommandOptions();
@@ -280,62 +280,6 @@ public class RetryCommandOptions {
     
     }
 
-    @Parameters(commandNames = {"run"}, commandDescription ="Execute an analysis from a custom binary.")
-    public class RunCommandOptions {
-    
-        @ParametersDelegate
-        public CommonCommandOptions commonOptions = commonCommandOptions;
-    
-        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
-        public String jsonFile;
-    
-        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
-        public Boolean jsonDataModel = false;
-    
-        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
-        public String study; 
-    
-        @Parameter(names = {"--job-id"}, description = "Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.", required = false, arity = 1)
-        public String jobId; 
-    
-        @Parameter(names = {"--job-description"}, description = "Job description", required = false, arity = 1)
-        public String jobDescription; 
-    
-        @Parameter(names = {"--job-depends-on"}, description = "Comma separated list of existing job IDs the job will depend on.", required = false, arity = 1)
-        public String jobDependsOn; 
-    
-        @Parameter(names = {"--job-tags"}, description = "Job tags", required = false, arity = 1)
-        public String jobTags; 
-    
-        @Parameter(names = {"--job-scheduled-start-time"}, description = "Time when the job is scheduled to start.", required = false, arity = 1)
-        public String jobScheduledStartTime; 
-    
-        @Parameter(names = {"--job-priority"}, description = "Priority of the job", required = false, arity = 1)
-        public String jobPriority; 
-    
-        @Parameter(names = {"--job-dry-run"}, description = "Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.", required = false, arity = 1)
-        public Boolean jobDryRun; 
-    
-        @Parameter(names = {"--command-line"}, description = "The body web service commandLine parameter", required = false, arity = 1)
-        public String commandLine;
-    
-        @Parameter(names = {"--docker-id"}, description = "The body web service id parameter", required = false, arity = 1)
-        public String dockerId;
-    
-        @Parameter(names = {"--docker-tag"}, description = "The body web service tag parameter", required = false, arity = 1)
-        public String dockerTag;
-    
-        @Parameter(names = {"--docker-token"}, description = "The body web service token parameter", required = false, arity = 1)
-        public String dockerToken;
-    
-        @Parameter(names = {"--git-repository"}, description = "The body web service repository parameter", required = false, arity = 1)
-        public String gitRepository;
-    
-        @Parameter(names = {"--git-reference"}, description = "The body web service reference parameter", required = false, arity = 1)
-        public String gitReference;
-    
-    }
-
     @Parameters(commandNames = {"search"}, commandDescription ="Job search method")
     public class SearchCommandOptions {
     
@@ -478,6 +422,62 @@ public class BuildToolCommandOptions {
     
     }
 
+    @Parameters(commandNames = {"tool-run"}, commandDescription ="Execute an analysis from a custom binary.")
+    public class RunToolCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--job-id"}, description = "Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.", required = false, arity = 1)
+        public String jobId; 
+    
+        @Parameter(names = {"--job-description"}, description = "Job description", required = false, arity = 1)
+        public String jobDescription; 
+    
+        @Parameter(names = {"--job-depends-on"}, description = "Comma separated list of existing job IDs the job will depend on.", required = false, arity = 1)
+        public String jobDependsOn; 
+    
+        @Parameter(names = {"--job-tags"}, description = "Job tags", required = false, arity = 1)
+        public String jobTags; 
+    
+        @Parameter(names = {"--job-scheduled-start-time"}, description = "Time when the job is scheduled to start.", required = false, arity = 1)
+        public String jobScheduledStartTime; 
+    
+        @Parameter(names = {"--job-priority"}, description = "Priority of the job", required = false, arity = 1)
+        public String jobPriority; 
+    
+        @Parameter(names = {"--job-dry-run"}, description = "Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.", required = false, arity = 1)
+        public Boolean jobDryRun; 
+    
+        @Parameter(names = {"--command-line"}, description = "The body web service commandLine parameter", required = false, arity = 1)
+        public String commandLine;
+    
+        @Parameter(names = {"--docker-id"}, description = "The body web service id parameter", required = false, arity = 1)
+        public String dockerId;
+    
+        @Parameter(names = {"--docker-tag"}, description = "The body web service tag parameter", required = false, arity = 1)
+        public String dockerTag;
+    
+        @Parameter(names = {"--docker-token"}, description = "The body web service token parameter", required = false, arity = 1)
+        public String dockerToken;
+    
+        @Parameter(names = {"--git-repository"}, description = "The body web service repository parameter", required = false, arity = 1)
+        public String gitRepository;
+    
+        @Parameter(names = {"--git-reference"}, description = "The body web service reference parameter", required = false, arity = 1)
+        public String gitReference;
+    
+    }
+
     @Parameters(commandNames = {"acl"}, commandDescription ="Return the acl of the job. If member is provided, it will only return the acl for the member.")
     public class AclCommandOptions {
     
diff --git a/opencga-client/src/main/R/R/Job-methods.R b/opencga-client/src/main/R/R/Job-methods.R
index 7e492eefa3e..103fbc77286 100644
--- a/opencga-client/src/main/R/R/Job-methods.R
+++ b/opencga-client/src/main/R/R/Job-methods.R
@@ -23,9 +23,9 @@
 #' | create | /{apiVersion}/jobs/create | study, body[*] |
 #' | distinct | /{apiVersion}/jobs/distinct | study, otherStudies, id, uuid, toolId, toolType, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted, field[*] |
 #' | retry | /{apiVersion}/jobs/retry | jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, study, body[*] |
-#' | run | /{apiVersion}/jobs/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | search | /{apiVersion}/jobs/search | include, exclude, limit, skip, count, study, otherStudies, id, uuid, toolId, toolType, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted |
 #' | buildTool | /{apiVersion}/jobs/tool/build | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
+#' | runTool | /{apiVersion}/jobs/tool/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | top | /{apiVersion}/jobs/top | limit, study, internalStatus, priority, userId, toolId |
 #' | acl | /{apiVersion}/jobs/{jobs}/acl | jobs[*], member, silent |
 #' | delete | /{apiVersion}/jobs/{jobs}/delete | study, jobs[*] |
@@ -97,20 +97,6 @@ setMethod("jobClient", "OpencgaR", function(OpencgaR, job, jobs, members, endpoi
         retry=fetchOpenCGA(object=OpencgaR, category="jobs", categoryId=NULL, subcategory=NULL, subcategoryId=NULL,
                 action="retry", params=params, httpMethod="POST", as.queryParam=NULL, ...),
 
-        #' @section Endpoint /{apiVersion}/jobs/run:
-        #' Execute an analysis from a custom binary.
-        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
-        #' @param jobId Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
-        #' @param jobDescription Job description.
-        #' @param jobDependsOn Comma separated list of existing job IDs the job will depend on.
-        #' @param jobTags Job tags.
-        #' @param jobScheduledStartTime Time when the job is scheduled to start.
-        #' @param jobPriority Priority of the job.
-        #' @param jobDryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
-        #' @param data NextFlow run parameters.
-        run=fetchOpenCGA(object=OpencgaR, category="jobs", categoryId=NULL, subcategory=NULL, subcategoryId=NULL,
-                action="run", params=params, httpMethod="POST", as.queryParam=NULL, ...),
-
         #' @section Endpoint /{apiVersion}/jobs/search:
         #' Job search method.
         #' @param include Fields included in the response, whole JSON path must be provided.
@@ -150,10 +136,24 @@ setMethod("jobClient", "OpencgaR", function(OpencgaR, job, jobs, members, endpoi
         #' @param jobScheduledStartTime Time when the job is scheduled to start.
         #' @param jobPriority Priority of the job.
         #' @param jobDryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
-        #' @param data NextFlow run parameters.
+        #' @param data body.
         buildTool=fetchOpenCGA(object=OpencgaR, category="jobs", categoryId=NULL, subcategory="tool",
                 subcategoryId=NULL, action="build", params=params, httpMethod="POST", as.queryParam=NULL, ...),
 
+        #' @section Endpoint /{apiVersion}/jobs/tool/run:
+        #' Execute an analysis from a custom binary.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param jobId Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+        #' @param jobDescription Job description.
+        #' @param jobDependsOn Comma separated list of existing job IDs the job will depend on.
+        #' @param jobTags Job tags.
+        #' @param jobScheduledStartTime Time when the job is scheduled to start.
+        #' @param jobPriority Priority of the job.
+        #' @param jobDryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+        #' @param data NextFlow run parameters.
+        runTool=fetchOpenCGA(object=OpencgaR, category="jobs", categoryId=NULL, subcategory="tool", subcategoryId=NULL,
+                action="run", params=params, httpMethod="POST", as.queryParam=NULL, ...),
+
         #' @section Endpoint /{apiVersion}/jobs/top:
         #' Provide a summary of the running jobs.
         #' @param limit Maximum number of jobs to be returned.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
index f81a5f3bff2..8d8e12cf5b3 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
@@ -138,28 +138,6 @@ public RestResponse<Job> retry(JobRetryParams data, ObjectMap params) throws Cli
         return execute("jobs", null, null, null, "retry", params, POST, Job.class);
     }
 
-    /**
-     * Execute an analysis from a custom binary.
-     * @param data NextFlow run parameters.
-     * @param params Map containing any of the following optional parameters.
-     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
-     *       jobId: Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
-     *       jobDescription: Job description.
-     *       jobDependsOn: Comma separated list of existing job IDs the job will depend on.
-     *       jobTags: Job tags.
-     *       jobScheduledStartTime: Time when the job is scheduled to start.
-     *       jobPriority: Priority of the job.
-     *       jobDryRun: Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all
-     *            parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
-     * @return a RestResponse object.
-     * @throws ClientException ClientException if there is any server error.
-     */
-    public RestResponse<Job> run(JobRunParams data, ObjectMap params) throws ClientException {
-        params = params != null ? params : new ObjectMap();
-        params.put("body", data);
-        return execute("jobs", null, null, null, "run", params, POST, Job.class);
-    }
-
     /**
      * Job search method.
      * @param params Map containing any of the following optional parameters.
@@ -201,7 +179,7 @@ public RestResponse<Job> search(ObjectMap params) throws ClientException {
 
     /**
      * Execute an analysis from a custom binary.
-     * @param data NextFlow run parameters.
+     * @param data body.
      * @param params Map containing any of the following optional parameters.
      *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
      *       jobId: Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
@@ -221,6 +199,28 @@ public RestResponse<Job> buildTool(JobToolBuildParams data, ObjectMap params) th
         return execute("jobs", null, "tool", null, "build", params, POST, Job.class);
     }
 
+    /**
+     * Execute an analysis from a custom binary.
+     * @param data NextFlow run parameters.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     *       jobId: Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+     *       jobDescription: Job description.
+     *       jobDependsOn: Comma separated list of existing job IDs the job will depend on.
+     *       jobTags: Job tags.
+     *       jobScheduledStartTime: Time when the job is scheduled to start.
+     *       jobPriority: Priority of the job.
+     *       jobDryRun: Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all
+     *            parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Job> runTool(JobRunParams data, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.put("body", data);
+        return execute("jobs", null, "tool", null, "run", params, POST, Job.class);
+    }
+
     /**
      * Provide a summary of the running jobs.
      * @param params Map containing any of the following optional parameters.
diff --git a/opencga-client/src/main/javascript/Job.js b/opencga-client/src/main/javascript/Job.js
index b82d6f0e9e6..df1de64c0be 100644
--- a/opencga-client/src/main/javascript/Job.js
+++ b/opencga-client/src/main/javascript/Job.js
@@ -103,25 +103,6 @@ export default class Job extends OpenCGAParentClass {
         return this._post("jobs", null, null, null, "retry", data, params);
     }
 
-    /** Execute an analysis from a custom binary.
-    * @param {Object} data - NextFlow run parameters.
-    * @param {Object} [params] - The Object containing the following optional parameters:
-    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
-    * @param {String} [params.jobId] - Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not
-    *     provided.
-    * @param {String} [params.jobDescription] - Job description.
-    * @param {String} [params.jobDependsOn] - Comma separated list of existing job IDs the job will depend on.
-    * @param {String} [params.jobTags] - Job tags.
-    * @param {String} [params.jobScheduledStartTime] - Time when the job is scheduled to start.
-    * @param {String} [params.jobPriority] - Priority of the job.
-    * @param {Boolean} [params.jobDryRun] - Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will
-    *     validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
-    * @returns {Promise} Promise object in the form of RestResponse instance.
-    */
-    run(data, params) {
-        return this._post("jobs", null, null, null, "run", data, params);
-    }
-
     /** Job search method
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {String} [params.include] - Fields included in the response, whole JSON path must be provided.
@@ -161,7 +142,7 @@ export default class Job extends OpenCGAParentClass {
     }
 
     /** Execute an analysis from a custom binary.
-    * @param {Object} data - NextFlow run parameters.
+    * @param {Object} data - body.
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
     * @param {String} [params.jobId] - Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not
@@ -179,6 +160,25 @@ export default class Job extends OpenCGAParentClass {
         return this._post("jobs", null, "tool", null, "build", data, params);
     }
 
+    /** Execute an analysis from a custom binary.
+    * @param {Object} data - NextFlow run parameters.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @param {String} [params.jobId] - Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not
+    *     provided.
+    * @param {String} [params.jobDescription] - Job description.
+    * @param {String} [params.jobDependsOn] - Comma separated list of existing job IDs the job will depend on.
+    * @param {String} [params.jobTags] - Job tags.
+    * @param {String} [params.jobScheduledStartTime] - Time when the job is scheduled to start.
+    * @param {String} [params.jobPriority] - Priority of the job.
+    * @param {Boolean} [params.jobDryRun] - Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will
+    *     validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    runTool(data, params) {
+        return this._post("jobs", null, "tool", null, "run", data, params);
+    }
+
     /** Provide a summary of the running jobs
     * @param {Object} [params] - The Object containing the following optional parameters:
     * @param {Number} [params.limit = "20"] - Maximum number of jobs to be returned. The default value is 20.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
index c28b9f264d0..9734e86479c 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
@@ -114,31 +114,6 @@ def retry(self, data=None, **options):
 
         return self._post(category='jobs', resource='retry', data=data, **options)
 
-    def run(self, data=None, **options):
-        """
-        Execute an analysis from a custom binary.
-        PATH: /{apiVersion}/jobs/run
-
-        :param dict data: NextFlow run parameters. (REQUIRED)
-        :param str study: Study [[organization@]project:]study where study and
-            project can be either the ID or UUID.
-        :param str job_id: Job ID. It must be a unique string within the
-            study. An ID will be autogenerated automatically if not provided.
-        :param str job_description: Job description.
-        :param str job_depends_on: Comma separated list of existing job IDs
-            the job will depend on.
-        :param str job_tags: Job tags.
-        :param str job_scheduled_start_time: Time when the job is scheduled to
-            start.
-        :param str job_priority: Priority of the job.
-        :param bool job_dry_run: Flag indicating that the job will be executed
-            in dry-run mode. In this mode, OpenCGA will validate that all
-            parameters and prerequisites are correctly set for successful
-            execution, but the job will not actually run.
-        """
-
-        return self._post(category='jobs', resource='run', data=data, **options)
-
     def search(self, **options):
         """
         Job search method.
@@ -196,7 +171,7 @@ def build_tool(self, data=None, **options):
         Execute an analysis from a custom binary.
         PATH: /{apiVersion}/jobs/tool/build
 
-        :param dict data: NextFlow run parameters. (REQUIRED)
+        :param dict data: body. (REQUIRED)
         :param str study: Study [[organization@]project:]study where study and
             project can be either the ID or UUID.
         :param str job_id: Job ID. It must be a unique string within the
@@ -216,6 +191,31 @@ def build_tool(self, data=None, **options):
 
         return self._post(category='jobs', resource='build', subcategory='tool', data=data, **options)
 
+    def run_tool(self, data=None, **options):
+        """
+        Execute an analysis from a custom binary.
+        PATH: /{apiVersion}/jobs/tool/run
+
+        :param dict data: NextFlow run parameters. (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str job_id: Job ID. It must be a unique string within the
+            study. An ID will be autogenerated automatically if not provided.
+        :param str job_description: Job description.
+        :param str job_depends_on: Comma separated list of existing job IDs
+            the job will depend on.
+        :param str job_tags: Job tags.
+        :param str job_scheduled_start_time: Time when the job is scheduled to
+            start.
+        :param str job_priority: Priority of the job.
+        :param bool job_dry_run: Flag indicating that the job will be executed
+            in dry-run mode. In this mode, OpenCGA will validate that all
+            parameters and prerequisites are correctly set for successful
+            execution, but the job will not actually run.
+        """
+
+        return self._post(category='jobs', resource='run', subcategory='tool', data=data, **options)
+
     def top(self, **options):
         """
         Provide a summary of the running jobs.
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
index adecf6baee8..8f65f561f74 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
@@ -121,7 +121,7 @@ public Response kill(
     }
 
     @POST
-    @Path("/run")
+    @Path("/tool/run")
     @Consumes(MediaType.APPLICATION_JSON)
     @ApiOperation(value = BinaryExecutor.DESCRIPTION, response = Job.class)
     public Response runByPost(

From 8cb935ab44df7003796898e3d6d1ee530a3bdde0 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sun, 22 Sep 2024 21:42:00 +0100
Subject: [PATCH 41/99] analysis: add new tool to build custom docker images

---
 .../analysis/binary/BioinfoToolBuilder.java   | 125 ++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BioinfoToolBuilder.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BioinfoToolBuilder.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BioinfoToolBuilder.java
new file mode 100644
index 00000000000..47897d10261
--- /dev/null
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BioinfoToolBuilder.java
@@ -0,0 +1,125 @@
+package org.opencb.opencga.analysis.binary;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.time.StopWatch;
+import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
+import org.opencb.opencga.core.common.TimeUtils;
+import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.job.JobToolBuildParams;
+import org.opencb.opencga.core.tools.annotations.Tool;
+import org.opencb.opencga.core.tools.annotations.ToolParams;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+
+@Tool(id = BioinfoToolBuilder.ID, resource = Enums.Resource.JOB, description = BioinfoToolBuilder.DESCRIPTION)
+public class BioinfoToolBuilder extends OpenCgaToolScopeStudy {
+
+    public static final String ID = "tool-builder";
+    public static final String DESCRIPTION = "Build an external bioinformatic tool from a GitHub repository URL.";
+
+    private static final String PYTHON_SCRIPT_NAME = "custom-tool-docker-build.py";
+
+    @ToolParams
+    protected JobToolBuildParams toolBuildParams = new JobToolBuildParams();
+
+    private final static Logger logger = LoggerFactory.getLogger(BioinfoToolBuilder.class);
+
+    @Override
+    protected void check() throws Exception {
+        super.check();
+
+        // Check any condition
+        if (toolBuildParams == null) {
+            throw new ToolException("Missing toolBuildParams");
+        }
+        if (StringUtils.isEmpty(toolBuildParams.getGitRepository())) {
+            throw new ToolException("Missing Git repository URL");
+        }
+        if (toolBuildParams.getDocker() == null
+                || StringUtils.isEmpty(toolBuildParams.getDocker().getOrganisation())
+                || StringUtils.isEmpty(toolBuildParams.getDocker().getName())
+                || StringUtils.isEmpty(toolBuildParams.getDocker().getTag())
+                || StringUtils.isEmpty(toolBuildParams.getDocker().getUser())
+                || StringUtils.isEmpty(toolBuildParams.getDocker().getPassword())
+        ) {
+            throw new ToolException("Missing Docker parameters, please provide the organisation, name, tag, user and password");
+        }
+        logger.debug("Checking finished, all seems fine");
+    }
+
+    @Override
+    protected void run() throws Exception {
+        // Build CLI params
+        StringBuilder cliBuilder = new StringBuilder();
+
+        // 1. Get the path to the custom-tool-docker-builder script
+        Path customToolDockerBuildPath = this.getOpencgaHome()
+                .resolve("cloud")
+                .resolve("docker")
+                .resolve("custom-tool-docker-builder");
+
+        // 2. Prepare basic CLI params
+        cliBuilder.append(PYTHON_SCRIPT_NAME).append(" ")
+                .append(customToolDockerBuildPath).append(" ")
+                .append("-t").append(" ").append(toolBuildParams.getGitRepository()).append(" ")
+                .append("-o").append(" ").append(toolBuildParams.getDocker().getOrganisation()).append(" ")
+                .append("-n").append(" ").append(toolBuildParams.getDocker().getName()).append(" ")
+                .append("-v").append(" ").append(toolBuildParams.getDocker().getTag()).append(" ")
+                .append("-u").append(" ").append(toolBuildParams.getDocker().getUser()).append(" ")
+                .append("-p").append(" ").append(toolBuildParams.getDocker().getPassword()).append(" ");
+
+        // 3. Check if 'apt-get' is provided
+        if (StringUtils.isNotEmpty(toolBuildParams.getAptGet())) {
+            cliBuilder.append("--apt-get").append(" ").append(toolBuildParams.getAptGet()).append(" ");
+        }
+
+        // 4. Check if 'installR' is provided
+        if (toolBuildParams.getInstallR() != null && toolBuildParams.getInstallR()) {
+            cliBuilder.append("--install-r").append(" ");
+        }
+
+        // 5. Execute the script
+        logger.info("CLI params: {}", cliBuilder);
+        // 5.1 Split the CLI params into a list
+        List<String> cliArgs = Arrays.asList(StringUtils.split(cliBuilder.toString(), " "));
+
+        // 5.2 Statr the stop watch
+        StopWatch stopWatch = StopWatch.createStarted();
+
+        // 5.3 Execute Python CLI
+        ProcessBuilder processBuilder = new ProcessBuilder(cliArgs);
+
+        // 5.4 Set the working directory of the process
+        processBuilder.directory(getOutDir().toFile());
+
+        // 5.5 Start execution
+        logger.info("Executing: {}", cliBuilder);
+        Process p;
+        try {
+            p = processBuilder.start();
+            BufferedReader input = new BufferedReader(new InputStreamReader(p.getInputStream()));
+            BufferedReader error = new BufferedReader(new InputStreamReader(p.getErrorStream()));
+            String line;
+            while ((line = input.readLine()) != null) {
+                logger.info("{}", line);
+            }
+            while ((line = error.readLine()) != null) {
+                logger.error("{} ", line);
+            }
+            p.waitFor();
+            input.close();
+        } catch (IOException | InterruptedException e) {
+            throw new RuntimeException("Error executing cli: " + e.getMessage(), e);
+        }
+        logger.info("Execution time: {}", TimeUtils.durationToString(stopWatch));
+    }
+
+}

From 9f6472ecf921604bc4c3a5f2e1f280a12706e362 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sun, 22 Sep 2024 22:01:08 +0100
Subject: [PATCH 42/99] analysis: some renaming and minor improvements

---
 .../CustomToolBuilder.java}                           | 10 +++++-----
 .../CustomToolExecutor.java}                          | 10 +++++-----
 .../internal/executors/WorkflowCommandExecutor.java   |  2 +-
 .../org/opencb/opencga/server/rest/JobWSServer.java   | 11 ++++++-----
 4 files changed, 17 insertions(+), 16 deletions(-)
 rename opencga-analysis/src/main/java/org/opencb/opencga/analysis/{binary/BioinfoToolBuilder.java => customTool/CustomToolBuilder.java} (94%)
 rename opencga-analysis/src/main/java/org/opencb/opencga/analysis/{binary/BinaryExecutor.java => customTool/CustomToolExecutor.java} (93%)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BioinfoToolBuilder.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
similarity index 94%
rename from opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BioinfoToolBuilder.java
rename to opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
index 47897d10261..226ea564b1c 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BioinfoToolBuilder.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
@@ -1,4 +1,4 @@
-package org.opencb.opencga.analysis.binary;
+package org.opencb.opencga.analysis.customTool;
 
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
@@ -19,10 +19,10 @@
 import java.util.Arrays;
 import java.util.List;
 
-@Tool(id = BioinfoToolBuilder.ID, resource = Enums.Resource.JOB, description = BioinfoToolBuilder.DESCRIPTION)
-public class BioinfoToolBuilder extends OpenCgaToolScopeStudy {
+@Tool(id = CustomToolBuilder.ID, resource = Enums.Resource.JOB, description = CustomToolBuilder.DESCRIPTION)
+public class CustomToolBuilder extends OpenCgaToolScopeStudy {
 
-    public static final String ID = "tool-builder";
+    public static final String ID = "custom-tool-builder";
     public static final String DESCRIPTION = "Build an external bioinformatic tool from a GitHub repository URL.";
 
     private static final String PYTHON_SCRIPT_NAME = "custom-tool-docker-build.py";
@@ -30,7 +30,7 @@ public class BioinfoToolBuilder extends OpenCgaToolScopeStudy {
     @ToolParams
     protected JobToolBuildParams toolBuildParams = new JobToolBuildParams();
 
-    private final static Logger logger = LoggerFactory.getLogger(BioinfoToolBuilder.class);
+    private final static Logger logger = LoggerFactory.getLogger(CustomToolBuilder.class);
 
     @Override
     protected void check() throws Exception {
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
similarity index 93%
rename from opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
rename to opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
index a4f162f6490..e22c8ffa3f1 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/binary/BinaryExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
@@ -1,4 +1,4 @@
-package org.opencb.opencga.analysis.binary;
+package org.opencb.opencga.analysis.customTool;
 
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
@@ -21,10 +21,10 @@
 import java.nio.file.Paths;
 import java.util.*;
 
-@Tool(id = BinaryExecutor.ID, resource = Enums.Resource.JOB, description = BinaryExecutor.DESCRIPTION)
-public class BinaryExecutor extends OpenCgaToolScopeStudy {
+@Tool(id = CustomToolExecutor.ID, resource = Enums.Resource.JOB, description = CustomToolExecutor.DESCRIPTION)
+public class CustomToolExecutor extends OpenCgaToolScopeStudy {
 
-    public final static String ID = "binary";
+    public final static String ID = "custom-tool";
     public static final String DESCRIPTION = "Execute an analysis from a custom binary.";
 
     @ToolParams
@@ -35,7 +35,7 @@ public class BinaryExecutor extends OpenCgaToolScopeStudy {
     List<AbstractMap.SimpleEntry<String, String>> inputBindings;
     private String dockerImage;
 
-    private final static Logger logger = LoggerFactory.getLogger(BinaryExecutor.class);
+    private final static Logger logger = LoggerFactory.getLogger(CustomToolExecutor.class);
 
     @Override
     protected void check() throws Exception {
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/executors/WorkflowCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/executors/WorkflowCommandExecutor.java
index df9905efe11..12898b57b57 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/executors/WorkflowCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/internal/executors/WorkflowCommandExecutor.java
@@ -31,7 +31,7 @@ public void execute() throws Exception {
         String subCommandString = getParsedSubCommand(workflowCommandOptions.jCommander);
         configure();
         switch (subCommandString) {
-            case "nextflow-run":
+            case "workflow":
                 nextflowRun();
                 break;
             default:
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
index 8f65f561f74..97c54b33734 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
@@ -20,7 +20,8 @@
 import org.apache.commons.lang3.StringUtils;
 import org.opencb.commons.datastore.core.Query;
 import org.opencb.commons.datastore.core.QueryOptions;
-import org.opencb.opencga.analysis.binary.BinaryExecutor;
+import org.opencb.opencga.analysis.customTool.CustomToolBuilder;
+import org.opencb.opencga.analysis.customTool.CustomToolExecutor;
 import org.opencb.opencga.catalog.db.api.JobDBAdaptor;
 import org.opencb.opencga.catalog.managers.JobManager;
 import org.opencb.opencga.catalog.utils.Constants;
@@ -123,7 +124,7 @@ public Response kill(
     @POST
     @Path("/tool/run")
     @Consumes(MediaType.APPLICATION_JSON)
-    @ApiOperation(value = BinaryExecutor.DESCRIPTION, response = Job.class)
+    @ApiOperation(value = CustomToolExecutor.DESCRIPTION, response = Job.class)
     public Response runByPost(
             @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String study,
             @ApiParam(value = ParamConstants.JOB_ID_CREATION_DESCRIPTION) @QueryParam(ParamConstants.JOB_ID) String jobName,
@@ -134,13 +135,13 @@ public Response runByPost(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = NextFlowRunParams.DESCRIPTION, required = true) JobRunParams params) {
-        return submitJob(BinaryExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(CustomToolExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
     @Path("/tool/build")
     @Consumes(MediaType.APPLICATION_JSON)
-    @ApiOperation(value = BinaryExecutor.DESCRIPTION, response = Job.class)
+    @ApiOperation(value = CustomToolExecutor.DESCRIPTION, response = Job.class)
     public Response dockerBuildByPost(
             @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String study,
             @ApiParam(value = ParamConstants.JOB_ID_CREATION_DESCRIPTION) @QueryParam(ParamConstants.JOB_ID) String jobName,
@@ -151,7 +152,7 @@ public Response dockerBuildByPost(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = "body", required = true) JobToolBuildParams params) {
-        return submitJob(BinaryExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(CustomToolBuilder.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET

From 74057f1922c8a9ba475a5fbe7d0d496cc3d0822b Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sun, 22 Sep 2024 23:43:49 +0100
Subject: [PATCH 43/99] analysis: fix path in CustomToolBuilder

---
 .../opencga/analysis/customTool/CustomToolBuilder.java     | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
index 226ea564b1c..9ce76295577 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
@@ -64,11 +64,12 @@ protected void run() throws Exception {
         Path customToolDockerBuildPath = this.getOpencgaHome()
                 .resolve("cloud")
                 .resolve("docker")
-                .resolve("custom-tool-docker-builder");
+                .resolve("custom-tool-docker-builder")
+                .resolve(PYTHON_SCRIPT_NAME);
+        logger.info("Executing custom-tool-docker-builder script: {}", customToolDockerBuildPath);
 
         // 2. Prepare basic CLI params
-        cliBuilder.append(PYTHON_SCRIPT_NAME).append(" ")
-                .append(customToolDockerBuildPath).append(" ")
+        cliBuilder.append(customToolDockerBuildPath).append(" ")
                 .append("-t").append(" ").append(toolBuildParams.getGitRepository()).append(" ")
                 .append("-o").append(" ").append(toolBuildParams.getDocker().getOrganisation()).append(" ")
                 .append("-n").append(" ").append(toolBuildParams.getDocker().getName()).append(" ")

From a489e3d53943acc12859e91e67e2e30f31120f13 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Mon, 23 Sep 2024 00:11:25 +0100
Subject: [PATCH 44/99] app: add execution permission to new
 custom-tool-docker-builder.py

---
 opencga-app/pom.xml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/opencga-app/pom.xml b/opencga-app/pom.xml
index af4cf1bec4a..9bdc66cb789 100644
--- a/opencga-app/pom.xml
+++ b/opencga-app/pom.xml
@@ -497,6 +497,12 @@
                                     </fileset>
                                 </chmod>
 
+                                <chmod perm="u+x">
+                                    <fileset dir="${build.dir}">
+                                        <include name="**/*.py"/>
+                                    </fileset>
+                                </chmod>
+
                                 <echo>Create clicompletion</echo>
                                 <exec executable="cp" failonerror="true">
                                     <arg value="${project.basedir}/target/appassembler/bin/opencga-clicompletion.sh"/>

From 5520cc9b4146c3528131621b716a3b175d1e00f1 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Mon, 23 Sep 2024 00:48:42 +0100
Subject: [PATCH 45/99] app: execute new custom-tool-docker-builder.py with
 command 'python3'

---
 .../opencga/analysis/customTool/CustomToolBuilder.java     | 7 ++++---
 .../core/models/workflow/WorkflowMinimumRequirements.java  | 4 ++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
index 9ce76295577..38b6cc739c7 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
@@ -61,15 +61,16 @@ protected void run() throws Exception {
         StringBuilder cliBuilder = new StringBuilder();
 
         // 1. Get the path to the custom-tool-docker-builder script
-        Path customToolDockerBuildPath = this.getOpencgaHome()
+        Path customToolDockerBuilderPath = this.getOpencgaHome()
                 .resolve("cloud")
                 .resolve("docker")
                 .resolve("custom-tool-docker-builder")
                 .resolve(PYTHON_SCRIPT_NAME);
-        logger.info("Executing custom-tool-docker-builder script: {}", customToolDockerBuildPath);
+        logger.info("Executing custom-tool-docker-builder script: {}", customToolDockerBuilderPath);
 
         // 2. Prepare basic CLI params
-        cliBuilder.append(customToolDockerBuildPath).append(" ")
+        cliBuilder.append("python3").append(" ")
+                .append(customToolDockerBuilderPath).append(" ")
                 .append("-t").append(" ").append(toolBuildParams.getGitRepository()).append(" ")
                 .append("-o").append(" ").append(toolBuildParams.getDocker().getOrganisation()).append(" ")
                 .append("-n").append(" ").append(toolBuildParams.getDocker().getName()).append(" ")
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
index c07a1d6801c..4943ba13755 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
@@ -6,10 +6,10 @@
 public class WorkflowMinimumRequirements {
 
     @DataField(id = "cpu", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_CPU_DESCRIPTION)
-    private int cpu;
+    private Integer cpu;
 
     @DataField(id = "memory", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_MEMORY_DESCRIPTION)
-    private int memory;
+    private Integer memory;
 
     public WorkflowMinimumRequirements() {
     }

From 02cf40ac9d272e83b8ba0f90e590bd0b09d3e608 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Mon, 23 Sep 2024 01:10:17 +0100
Subject: [PATCH 46/99] app: fix custom-tool-docker-builder.py

---
 .../opencb/opencga/analysis/customTool/CustomToolBuilder.java    | 1 +
 1 file changed, 1 insertion(+)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
index 38b6cc739c7..34c71ccc4c7 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolBuilder.java
@@ -71,6 +71,7 @@ protected void run() throws Exception {
         // 2. Prepare basic CLI params
         cliBuilder.append("python3").append(" ")
                 .append(customToolDockerBuilderPath).append(" ")
+                .append("push").append(" ")
                 .append("-t").append(" ").append(toolBuildParams.getGitRepository()).append(" ")
                 .append("-o").append(" ").append(toolBuildParams.getDocker().getOrganisation()).append(" ")
                 .append("-n").append(" ").append(toolBuildParams.getDocker().getName()).append(" ")

From 1a601249582d02925ee231abb1dd7a18deb33aeb Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Mon, 23 Sep 2024 08:09:24 +0100
Subject: [PATCH 47/99] app: fix custom-tool-docker-builder.py

---
 .../custom-tool-docker-builder/custom-tool-docker-build.py      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
index d0f3700e955..b8c915485f4 100755
--- a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
+++ b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
@@ -143,7 +143,7 @@ def push():
 
 # 1. Set build folder to default value if not set
 if args.custom_tool_dir is not None and not args.custom_tool_dir == "":
-    if args.custom_tool_dir.startswith("git@"):
+    if args.custom_tool_dir.startswith("git@") or args.custom_tool_dir.startswith("https://"):
         custom_build_folder = "/tmp/opencga-custom-tool"
         os.system("rm -rf " + custom_build_folder)
         os.system("git clone " + args.custom_tool_dir + " " + custom_build_folder)

From 2197de514a1bd4feaca74245e222b9214426f39c Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 23 Sep 2024 10:38:40 +0200
Subject: [PATCH 48/99] analysis: remove docker sock, #TASK-6445

---
 .../org/opencb/opencga/analysis/workflow/NextFlowExecutor.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index ba557e5bf56..83d8d68c7d6 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -163,7 +163,7 @@ protected void run() throws Exception {
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
-            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
+//            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {

From 927b8593ea15923455783e410b07ea96d8061d05 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 23 Sep 2024 11:22:32 +0200
Subject: [PATCH 49/99] catalog: allow querying by manager.id in workflows,
 #TASK-6445

---
 .../opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java    | 1 +
 .../opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java  | 1 +
 opencga-client/src/main/R/R/Workflow-methods.R              | 6 ++++--
 .../opencb/opencga/client/rest/clients/WorkflowClient.java  | 2 ++
 opencga-client/src/main/javascript/Workflow.js              | 2 ++
 .../main/python/pyopencga/rest_clients/workflow_client.py   | 4 ++++
 .../java/org/opencb/opencga/core/api/ParamConstants.java    | 2 ++
 .../org/opencb/opencga/server/rest/WorkflowWSServer.java    | 2 ++
 8 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
index b2ff9946d43..18a9eb67060 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/WorkflowDBAdaptor.java
@@ -29,6 +29,7 @@ enum QueryParams implements QueryParam {
         TAGS("tags", TEXT_ARRAY, ""),
         COMMAND_LINE("commandLine", TEXT, ""),
         MANAGER("manager", OBJECT, ""),
+        MANAGER_ID("manager.id", TEXT, ""),
         SCRIPTS("scripts", OBJECT, ""),
         VARIABLES("variables", OBJECT, ""),
         INTERNAL_REGISTRATION_USER_ID("internal.registrationUserId", TEXT, ""),
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
index d84291f6f07..2678f09353e 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/WorkflowMongoDBAdaptor.java
@@ -563,6 +563,7 @@ protected Bson parseQuery(Query query, Document extraQuery, String user)
                     case RELEASE:
                     case VERSION:
                     case INTERNAL_REGISTRATION_USER_ID:
+                    case MANAGER_ID:
                     case TYPE:
                     case DRAFT:
                         addAutoOrQuery(queryParam.key(), queryParam.key(), queryCopy, queryParam.type(), andBsonList);
diff --git a/opencga-client/src/main/R/R/Workflow-methods.R b/opencga-client/src/main/R/R/Workflow-methods.R
index 84e2d99f05e..1e7736bac30 100644
--- a/opencga-client/src/main/R/R/Workflow-methods.R
+++ b/opencga-client/src/main/R/R/Workflow-methods.R
@@ -21,9 +21,9 @@
 #' | -- | :-- | --: |
 #' | updateAcl | /{apiVersion}/workflows/acl/{members}/update | study, members[*], action[*], body[*] |
 #' | create | /{apiVersion}/workflows/create | include, exclude, study, includeResult, body[*] |
-#' | distinct | /{apiVersion}/workflows/distinct | study, id, name, uuid, tags, draft, internal.registrationUserId, type, creationDate, modificationDate, acl, release, snapshot, deleted, field[*] |
+#' | distinct | /{apiVersion}/workflows/distinct | study, id, name, uuid, tags, draft, internal.registrationUserId, manager.id, type, creationDate, modificationDate, acl, release, snapshot, deleted, field[*] |
 #' | run | /{apiVersion}/workflows/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
-#' | search | /{apiVersion}/workflows/search | include, exclude, limit, skip, count, study, id, name, uuid, tags, draft, internal.registrationUserId, type, creationDate, modificationDate, acl, release, snapshot, deleted |
+#' | search | /{apiVersion}/workflows/search | include, exclude, limit, skip, count, study, id, name, uuid, tags, draft, internal.registrationUserId, manager.id, type, creationDate, modificationDate, acl, release, snapshot, deleted |
 #' | update | /{apiVersion}/workflows/{workflowId}/update | include, exclude, workflowId[*], study, includeResult, body |
 #' | acl | /{apiVersion}/workflows/{workflows}/acl | workflows[*], study, member, silent |
 #' | delete | /{apiVersion}/workflows/{workflows}/delete | study, workflows[*] |
@@ -67,6 +67,7 @@ setMethod("workflowClient", "OpencgaR", function(OpencgaR, members, workflowId,
         #' @param tags Comma separated list of tags.
         #' @param draft Boolean field indicating whether the workflow is a draft or not.
         #' @param internal.registrationUserId UserId that created the workflow.
+        #' @param manager.id Id of the workflow system (Allowed values: NEXTFLOW).
         #' @param type Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
         #' @param creationDate Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
         #' @param modificationDate Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
@@ -106,6 +107,7 @@ setMethod("workflowClient", "OpencgaR", function(OpencgaR, members, workflowId,
         #' @param tags Comma separated list of tags.
         #' @param draft Boolean field indicating whether the workflow is a draft or not.
         #' @param internal.registrationUserId UserId that created the workflow.
+        #' @param manager.id Id of the workflow system (Allowed values: NEXTFLOW).
         #' @param type Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
         #' @param creationDate Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
         #' @param modificationDate Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
index 652f15f93e1..7627ba5e735 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
@@ -99,6 +99,7 @@ public RestResponse<Workflow> create(WorkflowCreateParams data, ObjectMap params
      *       tags: Comma separated list of tags.
      *       draft: Boolean field indicating whether the workflow is a draft or not.
      *       internal.registrationUserId: UserId that created the workflow.
+     *       manager.id: Id of the workflow system (Allowed values: NEXTFLOW).
      *       type: Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
      *       creationDate: Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
      *       modificationDate: Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
@@ -156,6 +157,7 @@ public RestResponse<Job> run(NextFlowRunParams data, ObjectMap params) throws Cl
      *       tags: Comma separated list of tags.
      *       draft: Boolean field indicating whether the workflow is a draft or not.
      *       internal.registrationUserId: UserId that created the workflow.
+     *       manager.id: Id of the workflow system (Allowed values: NEXTFLOW).
      *       type: Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
      *       creationDate: Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
      *       modificationDate: Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
diff --git a/opencga-client/src/main/javascript/Workflow.js b/opencga-client/src/main/javascript/Workflow.js
index f2dfd10cdf9..b1c93077a60 100644
--- a/opencga-client/src/main/javascript/Workflow.js
+++ b/opencga-client/src/main/javascript/Workflow.js
@@ -72,6 +72,7 @@ export default class Workflow extends OpenCGAParentClass {
     * @param {String} [params.tags] - Comma separated list of tags.
     * @param {Boolean} [params.draft] - Boolean field indicating whether the workflow is a draft or not.
     * @param {String} [params.internal.registrationUserId] - UserId that created the workflow.
+    * @param {String} [params.manager.id] - Id of the workflow system (Allowed values: NEXTFLOW).
     * @param {String} [params.type] - Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
     * @param {String} [params.creationDate] - Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
     * @param {String} [params.modificationDate] - Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
@@ -123,6 +124,7 @@ export default class Workflow extends OpenCGAParentClass {
     * @param {String} [params.tags] - Comma separated list of tags.
     * @param {Boolean} [params.draft] - Boolean field indicating whether the workflow is a draft or not.
     * @param {String} [params.internal.registrationUserId] - UserId that created the workflow.
+    * @param {String} [params.manager.id] - Id of the workflow system (Allowed values: NEXTFLOW).
     * @param {String} [params.type] - Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
     * @param {String} [params.creationDate] - Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
     * @param {String} [params.modificationDate] - Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
index fdf242702e7..8ac5c76b851 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
@@ -79,6 +79,8 @@ def distinct(self, field, **options):
             draft or not.
         :param str internal.registration_user_id: UserId that created the
             workflow.
+        :param str manager.id: Id of the workflow system (Allowed values:
+            NEXTFLOW).
         :param str type: Workflow type. Allowed types:
             [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
         :param str creation_date: Creation date. Format: yyyyMMddHHmmss.
@@ -154,6 +156,8 @@ def search(self, **options):
             draft or not.
         :param str internal.registration_user_id: UserId that created the
             workflow.
+        :param str manager.id: Id of the workflow system (Allowed values:
+            NEXTFLOW).
         :param str type: Workflow type. Allowed types:
             [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER].
         :param str creation_date: Creation date. Format: yyyyMMddHHmmss.
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
index 9a52837423d..9a49729c259 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
@@ -590,6 +590,7 @@ public class ParamConstants {
     public static final String WORKFLOWS_TAGS_PARAM = "tags";
     public static final String WORKFLOWS_DRAFT_PARAM = "draft";
     public static final String WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_PARAM = "internal.registrationUserId";
+    public static final String WORKFLOWS_MANAGER_ID_PARAM = "manager.id";
     public static final String WORKFLOWS_ID_DESCRIPTION = "Comma separated list of workflow IDs" + UP_TO_100 + REGEX_SUPPORT;
     public static final String WORKFLOWS_NAME_DESCRIPTION = "Comma separated list of workflow names" + UP_TO_100 + REGEX_SUPPORT;
     public static final String WORKFLOWS_UUID_DESCRIPTION = "Comma separated list of workflow UUIDs" + UP_TO_100;
@@ -598,6 +599,7 @@ public class ParamConstants {
     public static final String WORKFLOWS_TAGS_DESCRIPTION = "Comma separated list of tags";
     public static final String WORKFLOWS_DRAFT_DESCRIPTION = "Boolean field indicating whether the workflow is a draft or not.";
     public static final String WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_DESCRIPTION = "UserId that created the workflow.";
+    public static final String WORKFLOWS_MANAGER_ID_DESCRIPTION = "Id of the workflow system (Allowed values: NEXTFLOW).";
     public static final String WORKFLOW_SCRIPTS_ACTION_DESCRIPTION = "Action to be performed if the array of scripts is being updated "
             + "[SET, ADD, REMOVE]";
     public static final String WORKFLOW_SCRIPTS_ACTION_PARAM = "scriptsAction";
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
index 99d86ea8d58..6c766b87d44 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
@@ -122,6 +122,7 @@ public Response search(
             @ApiParam(value = ParamConstants.WORKFLOWS_TAGS_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TAGS_PARAM) String tags,
             @ApiParam(value = ParamConstants.WORKFLOWS_DRAFT_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_DRAFT_PARAM) Boolean draft,
             @ApiParam(value = ParamConstants.WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_PARAM) String userId,
+            @ApiParam(value = ParamConstants.WORKFLOWS_MANAGER_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_MANAGER_ID_PARAM) String systemId,
             @ApiParam(value = ParamConstants.WORKFLOWS_TYPE_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TYPE_PARAM) String type,
             @ApiParam(value = ParamConstants.CREATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.CREATION_DATE_PARAM) String creationDate,
             @ApiParam(value = ParamConstants.MODIFICATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.MODIFICATION_DATE_PARAM) String modificationDate,
@@ -149,6 +150,7 @@ public Response distinct(
             @ApiParam(value = ParamConstants.WORKFLOWS_TAGS_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TAGS_PARAM) String tags,
             @ApiParam(value = ParamConstants.WORKFLOWS_DRAFT_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_DRAFT_PARAM) Boolean draft,
             @ApiParam(value = ParamConstants.WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_INTERNAL_REGISTRATION_USER_ID_PARAM) String userId,
+            @ApiParam(value = ParamConstants.WORKFLOWS_MANAGER_ID_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_MANAGER_ID_PARAM) String systemId,
             @ApiParam(value = ParamConstants.WORKFLOWS_TYPE_DESCRIPTION) @QueryParam(ParamConstants.WORKFLOWS_TYPE_PARAM) String type,
             @ApiParam(value = ParamConstants.CREATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.CREATION_DATE_PARAM) String creationDate,
             @ApiParam(value = ParamConstants.MODIFICATION_DATE_DESCRIPTION) @QueryParam(ParamConstants.MODIFICATION_DATE_PARAM) String modificationDate,

From 881b43775c4827a84a3df2f2756678ef546c86f2 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 23 Sep 2024 11:56:12 +0200
Subject: [PATCH 50/99] catalog: add new fields to query by job, #TASK-6445

---
 .../main/executors/JobsCommandExecutor.java   |  8 +++++++
 .../cli/main/options/JobsCommandOptions.java  | 24 +++++++++++++++++++
 .../opencga/catalog/db/api/JobDBAdaptor.java  |  3 +++
 .../catalog/db/mongodb/JobMongoDBAdaptor.java |  6 ++++-
 .../src/main/resources/catalog-indexes.txt    |  3 ---
 opencga-client/src/main/R/R/Job-methods.R     | 12 ++++++++--
 .../client/rest/clients/JobClient.java        | 10 ++++++++
 opencga-client/src/main/javascript/Job.js     | 12 ++++++++++
 .../pyopencga/rest_clients/job_client.py      | 20 ++++++++++++++++
 .../opencga/core/api/ParamConstants.java      |  8 +++++++
 .../opencga/server/rest/JobWSServer.java      |  8 +++++++
 11 files changed, 108 insertions(+), 6 deletions(-)

diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
index ea9e2079b5d..6da7fef761c 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
@@ -221,6 +221,10 @@ private RestResponse<Object> distinct() throws Exception {
         queryParams.putIfNotEmpty("uuid", commandOptions.uuid);
         queryParams.putIfNotEmpty("toolId", commandOptions.toolId);
         queryParams.putIfNotEmpty("toolType", commandOptions.toolType);
+        queryParams.putIfNotEmpty("toolExternalExecutorId", commandOptions.toolExternalExecutorId);
+        queryParams.putIfNotEmpty("parentId", commandOptions.parentId);
+        queryParams.putIfNotNull("dryRun", commandOptions.dryRun);
+        queryParams.putIfNotNull("internalKillJobRequested", commandOptions.internalKillJobRequested);
         queryParams.putIfNotEmpty("userId", commandOptions.userId);
         queryParams.putIfNotEmpty("priority", commandOptions.priority);
         queryParams.putIfNotEmpty("status", commandOptions.status);
@@ -297,6 +301,10 @@ private RestResponse<Job> search() throws Exception {
         queryParams.putIfNotEmpty("uuid", commandOptions.uuid);
         queryParams.putIfNotEmpty("toolId", commandOptions.toolId);
         queryParams.putIfNotEmpty("toolType", commandOptions.toolType);
+        queryParams.putIfNotEmpty("toolExternalExecutorId", commandOptions.toolExternalExecutorId);
+        queryParams.putIfNotEmpty("parentId", commandOptions.parentId);
+        queryParams.putIfNotNull("dryRun", commandOptions.dryRun);
+        queryParams.putIfNotNull("internalKillJobRequested", commandOptions.internalKillJobRequested);
         queryParams.putIfNotEmpty("userId", commandOptions.userId);
         queryParams.putIfNotEmpty("priority", commandOptions.priority);
         queryParams.putIfNotEmpty("status", commandOptions.status);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
index b918e3ee137..ae9004c3613 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
@@ -195,6 +195,18 @@ public class DistinctCommandOptions {
         @Parameter(names = {"--tool-type"}, description = "Tool type executed by the job [OPERATION, ANALYSIS]", required = false, arity = 1)
         public String toolType; 
     
+        @Parameter(names = {"--tool.external-executor.id"}, description = "Id of the external executor. This field is only applicable for jobs executed by an external executor.", required = false, arity = 1)
+        public String toolExternalExecutorId; 
+    
+        @Parameter(names = {"--parent-id"}, description = "Job id that generated this job (if any).", required = false, arity = 1)
+        public String parentId; 
+    
+        @Parameter(names = {"--dry-run"}, description = "Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.", required = false, arity = 1)
+        public Boolean dryRun; 
+    
+        @Parameter(names = {"--internal.kill-job-requested"}, description = "Flag indicating that the user requested to kill the job.", required = false, arity = 1)
+        public Boolean internalKillJobRequested; 
+    
         @Parameter(names = {"--user-id"}, description = "User that created the job", required = false, arity = 1)
         public String userId; 
     
@@ -319,6 +331,18 @@ public class SearchCommandOptions {
         @Parameter(names = {"--tool-type"}, description = "Tool type executed by the job [OPERATION, ANALYSIS]", required = false, arity = 1)
         public String toolType; 
     
+        @Parameter(names = {"--tool.external-executor.id"}, description = "Id of the external executor. This field is only applicable for jobs executed by an external executor.", required = false, arity = 1)
+        public String toolExternalExecutorId; 
+    
+        @Parameter(names = {"--parent-id"}, description = "Job id that generated this job (if any).", required = false, arity = 1)
+        public String parentId; 
+    
+        @Parameter(names = {"--dry-run"}, description = "Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.", required = false, arity = 1)
+        public Boolean dryRun; 
+    
+        @Parameter(names = {"--internal.kill-job-requested"}, description = "Flag indicating that the user requested to kill the job.", required = false, arity = 1)
+        public Boolean internalKillJobRequested; 
+    
         @Parameter(names = {"--user-id"}, description = "User that created the job", required = false, arity = 1)
         public String userId; 
     
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/JobDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/JobDBAdaptor.java
index a8f1e717cae..b3f38e8a5cc 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/JobDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/api/JobDBAdaptor.java
@@ -112,8 +112,10 @@ enum QueryParams implements QueryParam {
 
         TOOL("tool", OBJECT, ""),
         TOOL_ID("tool.id", TEXT, ""),
+        TOOL_EXTERNAL_EXECUTOR_ID("tool.externalExecutor.id", TEXT, ""),
         TOOL_TYPE("tool.type", TEXT, ""),
         TOOL_EXTERNAL_EXECUTOR("tool.externalExecutor", OBJECT, ""),
+        PARENT_ID("parentId", TEXT, ""),
 
         PRIORITY("priority", TEXT, ""),
 
@@ -133,6 +135,7 @@ enum QueryParams implements QueryParam {
         INPUT("input", OBJECT, ""),
         OUTPUT("output", OBJECT, ""),
         DEPENDS_ON("dependsOn", TEXT_ARRAY, ""),
+        DRY_RUN("dryRun", BOOLEAN, ""),
         TAGS("tags", TEXT_ARRAY, ""),
 
         EXECUTION("execution", OBJECT, ""),
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/JobMongoDBAdaptor.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/JobMongoDBAdaptor.java
index cb59d9dca0b..630e4cb83ed 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/JobMongoDBAdaptor.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/db/mongodb/JobMongoDBAdaptor.java
@@ -886,7 +886,11 @@ private Bson parseQuery(Query query, Document extraQuery, QueryOptions options,
                     case UUID:
                     case USER_ID:
                     case TOOL_TYPE:
-                    case PRIORITY: // TODO: This filter is not indexed. We should change it and query _priority instead.
+                    case PRIORITY:
+                    case TOOL_EXTERNAL_EXECUTOR_ID:
+                    case PARENT_ID:
+                    case DRY_RUN:
+                    case INTERNAL_KILL_JOB_REQUESTED:
 //                    case START_TIME:
 //                    case END_TIME:
 //                    case OUTPUT_ERROR:
diff --git a/opencga-catalog/src/main/resources/catalog-indexes.txt b/opencga-catalog/src/main/resources/catalog-indexes.txt
index eb2c34d47fb..7710a8ce03a 100644
--- a/opencga-catalog/src/main/resources/catalog-indexes.txt
+++ b/opencga-catalog/src/main/resources/catalog-indexes.txt
@@ -23,7 +23,6 @@
 {"collections": ["job"], "fields": {"tool.externalExecutor.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"userId": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"parentId": 1, "studyUid": 1}, "options": {}}
-{"collections": ["job"], "fields": {"dependsOn.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"outDir.uid": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"input.uid": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"output.uid": 1, "studyUid": 1}, "options": {}}
@@ -34,8 +33,6 @@
 {"collections": ["job"], "fields": {"internal.status.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"internal.status.id": 1, "_priority": 1, "_creationDate": 1}, "options": {}}
 {"collections": ["job"], "fields": {"internal.killJobRequested": 1, "studyUid": 1}, "options": {}}
-{"collections": ["job"], "fields": {"_priority": 1, "_creationDate": 1, "studyUid": 1}, "options": {}}
-{"collections": ["job"], "fields": {"_priority": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"_creationDate": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"_modificationDate": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"studyUid": 1, "_acl": 1}, "options": {}}
diff --git a/opencga-client/src/main/R/R/Job-methods.R b/opencga-client/src/main/R/R/Job-methods.R
index 103fbc77286..745f5578c55 100644
--- a/opencga-client/src/main/R/R/Job-methods.R
+++ b/opencga-client/src/main/R/R/Job-methods.R
@@ -21,9 +21,9 @@
 #' | -- | :-- | --: |
 #' | updateAcl | /{apiVersion}/jobs/acl/{members}/update | members[*], action[*], body[*] |
 #' | create | /{apiVersion}/jobs/create | study, body[*] |
-#' | distinct | /{apiVersion}/jobs/distinct | study, otherStudies, id, uuid, toolId, toolType, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted, field[*] |
+#' | distinct | /{apiVersion}/jobs/distinct | study, otherStudies, id, uuid, toolId, toolType, tool.externalExecutor.id, parentId, dryRun, internal.killJobRequested, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted, field[*] |
 #' | retry | /{apiVersion}/jobs/retry | jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, study, body[*] |
-#' | search | /{apiVersion}/jobs/search | include, exclude, limit, skip, count, study, otherStudies, id, uuid, toolId, toolType, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted |
+#' | search | /{apiVersion}/jobs/search | include, exclude, limit, skip, count, study, otherStudies, id, uuid, toolId, toolType, tool.externalExecutor.id, parentId, dryRun, internal.killJobRequested, userId, priority, status, internalStatus, creationDate, modificationDate, visited, tags, input, output, acl, release, deleted |
 #' | buildTool | /{apiVersion}/jobs/tool/build | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | runTool | /{apiVersion}/jobs/tool/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | top | /{apiVersion}/jobs/top | limit, study, internalStatus, priority, userId, toolId |
@@ -68,6 +68,10 @@ setMethod("jobClient", "OpencgaR", function(OpencgaR, job, jobs, members, endpoi
         #' @param uuid Comma separated list of job UUIDs up to a maximum of 100.
         #' @param toolId Tool ID executed by the job. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
         #' @param toolType Tool type executed by the job [OPERATION, ANALYSIS].
+        #' @param tool.externalExecutor.id Id of the external executor. This field is only applicable for jobs executed by an external executor.
+        #' @param parentId Job id that generated this job (if any).
+        #' @param dryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+        #' @param internal.killJobRequested Flag indicating that the user requested to kill the job.
         #' @param userId User that created the job.
         #' @param priority Priority of the job.
         #' @param status Filter by status.
@@ -110,6 +114,10 @@ setMethod("jobClient", "OpencgaR", function(OpencgaR, job, jobs, members, endpoi
         #' @param uuid Comma separated list of job UUIDs up to a maximum of 100.
         #' @param toolId Tool ID executed by the job. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
         #' @param toolType Tool type executed by the job [OPERATION, ANALYSIS].
+        #' @param tool.externalExecutor.id Id of the external executor. This field is only applicable for jobs executed by an external executor.
+        #' @param parentId Job id that generated this job (if any).
+        #' @param dryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+        #' @param internal.killJobRequested Flag indicating that the user requested to kill the job.
         #' @param userId User that created the job.
         #' @param priority Priority of the job.
         #' @param status Filter by status.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
index 8d8e12cf5b3..cddc9960f41 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/JobClient.java
@@ -95,6 +95,11 @@ public RestResponse<Job> create(JobCreateParams data, ObjectMap params) throws C
      *       toolId: Tool ID executed by the job. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g.
      *            '~value' for case sensitive, '~/value/i' for case insensitive search.
      *       toolType: Tool type executed by the job [OPERATION, ANALYSIS].
+     *       tool.externalExecutor.id: Id of the external executor. This field is only applicable for jobs executed by an external executor.
+     *       parentId: Job id that generated this job (if any).
+     *       dryRun: Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters
+     *            and prerequisites are correctly set for successful execution, but the job will not actually run.
+     *       internal.killJobRequested: Flag indicating that the user requested to kill the job.
      *       userId: User that created the job.
      *       priority: Priority of the job.
      *       status: Filter by status.
@@ -154,6 +159,11 @@ public RestResponse<Job> retry(JobRetryParams data, ObjectMap params) throws Cli
      *       toolId: Tool ID executed by the job. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g.
      *            '~value' for case sensitive, '~/value/i' for case insensitive search.
      *       toolType: Tool type executed by the job [OPERATION, ANALYSIS].
+     *       tool.externalExecutor.id: Id of the external executor. This field is only applicable for jobs executed by an external executor.
+     *       parentId: Job id that generated this job (if any).
+     *       dryRun: Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters
+     *            and prerequisites are correctly set for successful execution, but the job will not actually run.
+     *       internal.killJobRequested: Flag indicating that the user requested to kill the job.
      *       userId: User that created the job.
      *       priority: Priority of the job.
      *       status: Filter by status.
diff --git a/opencga-client/src/main/javascript/Job.js b/opencga-client/src/main/javascript/Job.js
index df1de64c0be..acffe2f30ba 100644
--- a/opencga-client/src/main/javascript/Job.js
+++ b/opencga-client/src/main/javascript/Job.js
@@ -66,6 +66,12 @@ export default class Job extends OpenCGAParentClass {
     * @param {String} [params.toolId] - Tool ID executed by the job. Also admits basic regular expressions using the operator '~', i.e.
     *     '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
     * @param {String} [params.toolType] - Tool type executed by the job [OPERATION, ANALYSIS].
+    * @param {String} [params.tool.externalExecutor.id] - Id of the external executor. This field is only applicable for jobs executed by an
+    *     external executor.
+    * @param {String} [params.parentId] - Job id that generated this job (if any).
+    * @param {Boolean} [params.dryRun] - Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate
+    *     that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+    * @param {Boolean} [params.internal.killJobRequested] - Flag indicating that the user requested to kill the job.
     * @param {String} [params.userId] - User that created the job.
     * @param {String} [params.priority] - Priority of the job.
     * @param {String} [params.status] - Filter by status.
@@ -120,6 +126,12 @@ export default class Job extends OpenCGAParentClass {
     * @param {String} [params.toolId] - Tool ID executed by the job. Also admits basic regular expressions using the operator '~', i.e.
     *     '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.
     * @param {String} [params.toolType] - Tool type executed by the job [OPERATION, ANALYSIS].
+    * @param {String} [params.tool.externalExecutor.id] - Id of the external executor. This field is only applicable for jobs executed by an
+    *     external executor.
+    * @param {String} [params.parentId] - Job id that generated this job (if any).
+    * @param {Boolean} [params.dryRun] - Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate
+    *     that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+    * @param {Boolean} [params.internal.killJobRequested] - Flag indicating that the user requested to kill the job.
     * @param {String} [params.userId] - User that created the job.
     * @param {String} [params.priority] - Priority of the job.
     * @param {String} [params.status] - Filter by status.
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
index 9734e86479c..aab6342f11f 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/job_client.py
@@ -70,6 +70,16 @@ def distinct(self, field, **options):
             search.
         :param str tool_type: Tool type executed by the job [OPERATION,
             ANALYSIS].
+        :param str tool.external_executor.id: Id of the external executor.
+            This field is only applicable for jobs executed by an external
+            executor.
+        :param str parent_id: Job id that generated this job (if any).
+        :param bool dry_run: Flag indicating that the job will be executed in
+            dry-run mode. In this mode, OpenCGA will validate that all
+            parameters and prerequisites are correctly set for successful
+            execution, but the job will not actually run.
+        :param bool internal.kill_job_requested: Flag indicating that the user
+            requested to kill the job.
         :param str user_id: User that created the job.
         :param str priority: Priority of the job.
         :param str status: Filter by status.
@@ -143,6 +153,16 @@ def search(self, **options):
             search.
         :param str tool_type: Tool type executed by the job [OPERATION,
             ANALYSIS].
+        :param str tool.external_executor.id: Id of the external executor.
+            This field is only applicable for jobs executed by an external
+            executor.
+        :param str parent_id: Job id that generated this job (if any).
+        :param bool dry_run: Flag indicating that the job will be executed in
+            dry-run mode. In this mode, OpenCGA will validate that all
+            parameters and prerequisites are correctly set for successful
+            execution, but the job will not actually run.
+        :param bool internal.kill_job_requested: Flag indicating that the user
+            requested to kill the job.
         :param str user_id: User that created the job.
         :param str priority: Priority of the job.
         :param str status: Filter by status.
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
index 9a49729c259..67f06aa1f32 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
@@ -554,6 +554,14 @@ public class ParamConstants {
     public static final String JOB_DEPENDS_ON_PARAM = "dependsOn";
     public static final String JOB_DEPENDS_ON_DESCRIPTION = "Comma separated list of existing job IDs the job will depend on.";
     public static final String JOB_TOOL_ID_PARAM = "toolId";
+    public static final String JOB_TOOL_EXTERNAL_EXECUTOR_ID_PARAM = "tool.externalExecutor.id";
+    public static final String JOB_TOOL_EXTERNAL_EXECUTOR_ID_DESCRIPTION = "Id of the external executor. This field is only applicable for "
+            + "jobs executed by an external executor.";
+    public static final String JOB_DRY_RUN_PARAM = "dryRun";
+    public static final String JOB_PARENT_ID_PARAM = "parentId";
+    public static final String JOB_PARENT_ID_DESCRIPTION = "Job id that generated this job (if any).";
+    public static final String JOB_INTERNAL_KILL_JOB_REQUESTED_PARAM = "internal.killJobRequested";
+    public static final String JOB_INTERNAL_KILL_JOB_REQUESTED_DESCRIPTION = "Flag indicating that the user requested to kill the job.";
     public static final String JOB_TOOL_TYPE_PARAM = "toolType";
     public static final String JOB_TOOL_ID_DESCRIPTION = "Tool ID executed by the job" + REGEX_SUPPORT;
     public static final String JOB_TOOL_TYPE_DESCRIPTION = "Tool type executed by the job [OPERATION, ANALYSIS]";
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
index 97c54b33734..67a34804c84 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
@@ -233,6 +233,10 @@ public Response search(
             @ApiParam(value = ParamConstants.JOB_UUIDS_DESCRIPTION) @QueryParam(ParamConstants.JOB_UUID_PARAM) String uuid,
             @ApiParam(value = ParamConstants.JOB_TOOL_ID_DESCRIPTION) @QueryParam(ParamConstants.JOB_TOOL_ID_PARAM) String toolId,
             @ApiParam(value = ParamConstants.JOB_TOOL_TYPE_DESCRIPTION) @QueryParam(ParamConstants.JOB_TOOL_TYPE_PARAM) String toolType,
+            @ApiParam(value = ParamConstants.JOB_TOOL_EXTERNAL_EXECUTOR_ID_DESCRIPTION) @QueryParam(ParamConstants.JOB_TOOL_EXTERNAL_EXECUTOR_ID_PARAM) String externalExecutorId,
+            @ApiParam(value = ParamConstants.JOB_PARENT_ID_DESCRIPTION) @QueryParam(ParamConstants.JOB_PARENT_ID_PARAM) String parentId,
+            @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN_PARAM) Boolean dryRun,
+            @ApiParam(value = ParamConstants.JOB_INTERNAL_KILL_JOB_REQUESTED_DESCRIPTION) @QueryParam(ParamConstants.JOB_INTERNAL_KILL_JOB_REQUESTED_PARAM) Boolean killRequested,
             @ApiParam(value = ParamConstants.JOB_USER_DESCRIPTION) @QueryParam(ParamConstants.JOB_USER_PARAM) String user,
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.JOB_PRIORITY_PARAM) String priority,
             @ApiParam(value = ParamConstants.JOB_STATUS_DESCRIPTION) @QueryParam(ParamConstants.JOB_STATUS_PARAM) String status,
@@ -264,6 +268,10 @@ public Response distinct(
             @ApiParam(value = ParamConstants.JOB_UUIDS_DESCRIPTION) @QueryParam(ParamConstants.JOB_UUID_PARAM) String uuid,
             @ApiParam(value = ParamConstants.JOB_TOOL_ID_DESCRIPTION) @QueryParam(ParamConstants.JOB_TOOL_ID_PARAM) String toolId,
             @ApiParam(value = ParamConstants.JOB_TOOL_TYPE_DESCRIPTION) @QueryParam(ParamConstants.JOB_TOOL_TYPE_PARAM) String toolType,
+            @ApiParam(value = ParamConstants.JOB_TOOL_EXTERNAL_EXECUTOR_ID_DESCRIPTION) @QueryParam(ParamConstants.JOB_TOOL_EXTERNAL_EXECUTOR_ID_PARAM) String externalExecutorId,
+            @ApiParam(value = ParamConstants.JOB_PARENT_ID_DESCRIPTION) @QueryParam(ParamConstants.JOB_PARENT_ID_PARAM) String parentId,
+            @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN_PARAM) Boolean dryRun,
+            @ApiParam(value = ParamConstants.JOB_INTERNAL_KILL_JOB_REQUESTED_DESCRIPTION) @QueryParam(ParamConstants.JOB_INTERNAL_KILL_JOB_REQUESTED_PARAM) Boolean killRequested,
             @ApiParam(value = ParamConstants.JOB_USER_DESCRIPTION) @QueryParam(ParamConstants.JOB_USER_PARAM) String user,
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.JOB_PRIORITY_PARAM) String priority,
             @ApiParam(value = ParamConstants.JOB_STATUS_DESCRIPTION) @QueryParam(ParamConstants.JOB_STATUS_PARAM) String status,

From b89b9d72bcb96b2508519718c162b1edf7384b5e Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Mon, 23 Sep 2024 12:44:28 +0100
Subject: [PATCH 51/99] app: add docker dependency to
 custom-tool-docker-builder.py

---
 .../custom-tool-docker-builder/custom-tool-docker-build.py      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
index b8c915485f4..4eff4d669d9 100755
--- a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
+++ b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
@@ -74,7 +74,7 @@ def dockerfile():
 
         ## Install Ubuntu OS dependencies with 'apt'
         # 1. Update Ubuntu and install base libraries
-        f.write("RUN apt update && apt -y upgrade && apt install -y python3 python3-pip && \\ \n")
+        f.write("RUN apt update && apt -y upgrade && apt install -y python3 python3-pip docker-ce docker-ce-cli containerd.io && \\ \n")
 
         # 2. Install R
         if args.install_r is True:

From a814182ec1ee114b5db8b688dd7019f3f94120f4 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 23 Sep 2024 16:13:47 +0200
Subject: [PATCH 52/99] analysis: try docker.sock and docker host, #TASK-6445

---
 .../opencb/opencga/analysis/workflow/NextFlowExecutor.java   | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 83d8d68c7d6..2c39542eb97 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -161,9 +161,10 @@ protected void run() throws Exception {
         StringBuilder stringBuilder = new StringBuilder()
                 .append("bash -c \"nextflow -c ").append(inputDir).append("/nextflow.config").append(" run ");
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
-//            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
+            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
-//            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
+            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
+            dockerParams.put("-e", "DOCKER_HOST='tcp://localhost:2375'");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {

From b0acafadf8e309a2fce449c322c25c792471b0a9 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 23 Sep 2024 16:34:17 +0200
Subject: [PATCH 53/99] analysis: fix docker cli generation, #TASK-6445

---
 .../org/opencb/opencga/analysis/workflow/NextFlowExecutor.java  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 2c39542eb97..d4c4dbe9a9a 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -161,7 +161,7 @@ protected void run() throws Exception {
         StringBuilder stringBuilder = new StringBuilder()
                 .append("bash -c \"nextflow -c ").append(inputDir).append("/nextflow.config").append(" run ");
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
-            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
+//            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
             dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
             dockerParams.put("-e", "DOCKER_HOST='tcp://localhost:2375'");

From 509b9e3516cc8a195ce5c52f3a7f86230c888ac6 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 23 Sep 2024 16:58:58 +0200
Subject: [PATCH 54/99] analysis: add network host to container, #TASK-6445

---
 .../opencb/opencga/analysis/workflow/NextFlowExecutor.java   | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index d4c4dbe9a9a..3a9ebaaccdc 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -163,8 +163,9 @@ protected void run() throws Exception {
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
-            dockerParams.put("-v", "/var/run/docker.sock:/var/run/docker.sock");
-            dockerParams.put("-e", "DOCKER_HOST='tcp://localhost:2375'");
+            dockerParams.put("--volume", "/var/run/docker.sock:/var/run/docker.sock");
+            dockerParams.put("--env", "DOCKER_HOST='tcp://localhost:2375'");
+            dockerParams.put("--network", "host");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {

From 5540f4d5fd2fce71b67f37b95b962e2774542552 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Tue, 24 Sep 2024 00:30:00 +0100
Subject: [PATCH 55/99] app: add Docker to custom tool docker build script

---
 .../custom-tool-docker-build.py                   | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
index 4eff4d669d9..d8238f3e87a 100755
--- a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
+++ b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
@@ -74,17 +74,24 @@ def dockerfile():
 
         ## Install Ubuntu OS dependencies with 'apt'
         # 1. Update Ubuntu and install base libraries
-        f.write("RUN apt update && apt -y upgrade && apt install -y python3 python3-pip docker-ce docker-ce-cli containerd.io && \\ \n")
+        f.write("RUN apt update && apt -y upgrade && apt install -y python3 python3-pip ca-certificates curl && \\ \n")
 
-        # 2. Install R
+        # 2. Install Docker
+        f.write("install -m 0755 -d /etc/apt/keyrings && \\ \n")
+        f.write("curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc && \\ \n")
+        f.write("chmod a+r /etc/apt/keyrings/docker.asc && \\ \n")
+        f.write("echo \"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo \"$VERSION_CODENAME\") stable\" | tee /etc/apt/sources.list.d/docker.list > /dev/null && \\ \n")
+        f.write("apt update && apt install -y docker-ce docker-ce-cli containerd.io && \\ \n")
+
+        # 3. Install R
         if args.install_r is True:
             f.write("apt install -y r-base && \\ \n")
 
-        # 3. Install user's apt dependencies
+        # 4. Install user's apt dependencies
         if args.apt_get is not None and not args.apt_get == "":
             f.write("apt install -y " + args.apt_get.replace(",", " ") + " && \\ \n")
 
-        # 4. Check and build C/C++ tools
+        # 5. Check and build C/C++ tools
         if os.path.isfile(custom_build_folder + "/makefile") or os.path.isfile(custom_build_folder + "/Makefile"):
             f.write("apt install -y build-essential && \\ \n")
             f.write("make -C /opt/app && \\ \n")

From b90b3d61a33624fd6f80958c0130338e1501d957 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Tue, 24 Sep 2024 01:20:34 +0100
Subject: [PATCH 56/99] app: add docker in docker to custom tool docker build
 script

---
 .../custom-tool-docker-build.py                | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
index d8238f3e87a..9e3047c91aa 100755
--- a/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
+++ b/opencga-app/app/cloud/docker/custom-tool-docker-builder/custom-tool-docker-build.py
@@ -114,11 +114,19 @@ def build():
     image = get_docker_image_id()
     print(shell_colors['blue'] + "Building " + image + " ..." + shell_colors['reset'])
 
-    command = ("docker build"
-               + " -t " + image
-               + " -f " + custom_build_folder +  "/Dockerfile"
-               # + " " + args.docker_build_args + " "
-               + " " + custom_build_folder)
+    if os.path.isfile("/var/run/docker.sock"):
+        command = ("docker build"
+                   + " -t " + image
+                   + " -f " + custom_build_folder +  "/Dockerfile"
+                   + " -v /var/run/docker.sock:/var/run/docker.sock"
+                   + " --env DOCKER_HOST='tcp://localhost:2375'"
+                   + " --network host"
+                   + " " + custom_build_folder)
+    else:
+        command = ("docker build"
+                   + " -t " + image
+                   + " -f " + custom_build_folder +  "/Dockerfile"
+                   + " " + custom_build_folder)
     run(command)
 
 def tag_latest(image):

From 35efede96b677fb0b2cbc169c67da207e8232e96 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 24 Sep 2024 10:27:27 +0200
Subject: [PATCH 57/99] analysis: adapt executor to accept dynamic docker
 params, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 3a9ebaaccdc..1e98e72c8b6 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -56,6 +56,8 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
     // Build list of inputfiles in case we need to specifically mount them in read only mode
     List<AbstractMap.SimpleEntry<String, String>> inputBindings;
 
+    private Map<String, String> dockerParams;
+
     private Thread thread;
     private final int monitorThreadPeriod = 5000;
 
@@ -72,6 +74,8 @@ protected void check() throws Exception {
             throw new IllegalArgumentException("Missing Nextflow ID");
         }
 
+        dockerParams = new HashMap<>();
+
         OpenCGAResult<Workflow> result;
         if (nextflowParams.getVersion() != null) {
             Query query = new Query(WorkflowDBAdaptor.QueryParams.VERSION.key(), nextflowParams.getVersion());
@@ -108,6 +112,12 @@ protected void check() throws Exception {
 
             StringBuilder cliParamsBuilder = new StringBuilder();
             for (Map.Entry<String, String> entry : nextflowParams.getParams().entrySet()) {
+                if (entry.getKey().equalsIgnoreCase("dockerParams")) {
+                    Arrays.asList(entry.getValue().split(",")).forEach(s -> {
+                        String[] split = s.split("==");
+                        dockerParams.put(split[0], split[1]);
+                    });
+                }
                 if (entry.getKey().startsWith("-")) {
                     cliParamsBuilder.append(entry.getKey()).append(" ");
                 } else {
@@ -150,8 +160,8 @@ protected void run() throws Exception {
             throw new RuntimeException("Can't fetch nextflow.config file");
         }
 
-        Map<String, String> dockerParams = new HashMap<>();
-        dockerParams.put("user", "0:0");
+
+//        dockerParams.put("user", "0:0");
 
         // Build output binding
         AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(getOutDir().toAbsolutePath().toString(),
@@ -163,9 +173,9 @@ protected void run() throws Exception {
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
-            dockerParams.put("--volume", "/var/run/docker.sock:/var/run/docker.sock");
-            dockerParams.put("--env", "DOCKER_HOST='tcp://localhost:2375'");
-            dockerParams.put("--network", "host");
+//            dockerParams.put("--volume", "/var/run/docker.sock:/var/run/docker.sock");
+//            dockerParams.put("--env", "DOCKER_HOST='tcp://localhost:2375'");
+//            dockerParams.put("--network", "host");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {

From 21510e70dca154f864862b77e9b4003d7a5fd741 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 24 Sep 2024 10:46:34 +0200
Subject: [PATCH 58/99] analysis: remove some params from cli, #TASK-6445

---
 .../org/opencb/opencga/analysis/workflow/NextFlowExecutor.java   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 1e98e72c8b6..4b97b455115 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -117,6 +117,7 @@ protected void check() throws Exception {
                         String[] split = s.split("==");
                         dockerParams.put(split[0], split[1]);
                     });
+                    continue;
                 }
                 if (entry.getKey().startsWith("-")) {
                     cliParamsBuilder.append(entry.getKey()).append(" ");

From 3328c250c859089e2c6b9a988a4e933514155e9b Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 25 Sep 2024 15:28:21 +0200
Subject: [PATCH 59/99] analysis: new nextflow docker, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   | 56 ++++++++++---------
 1 file changed, 31 insertions(+), 25 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 4b97b455115..4c1fed07976 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -34,7 +34,6 @@
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.*;
@@ -61,8 +60,8 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
     private Thread thread;
     private final int monitorThreadPeriod = 5000;
 
-    private final Path inputDir = Paths.get("/data/input");
-    private final String outputDir = "/data/output";
+//    private final Path inputDir = Paths.get("/data/input");
+//    private final String outputDir = "/data/output";
 
     private final static Logger logger = LoggerFactory.getLogger(NextFlowExecutor.class);
 
@@ -127,8 +126,9 @@ protected void check() throws Exception {
                 if (StringUtils.isNotEmpty(entry.getValue())) {
                     if (inputFileUtils.isValidOpenCGAFile(entry.getValue())) {
                         File file = inputFileUtils.getOpenCGAFile(study, entry.getValue(), token);
-                        inputBindings.add(new AbstractMap.SimpleEntry<>(file.getUri().getPath(), inputDir.resolve(file.getName()).toString()));
-                        cliParamsBuilder.append(inputDir).append("/").append(file.getName()).append(" ");
+                        String path = file.getUri().getPath();
+                        inputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
+                        cliParamsBuilder.append(path).append(" ");
                     } else {
                         cliParamsBuilder.append(entry.getValue()).append(" ");
                     }
@@ -143,44 +143,50 @@ protected void check() throws Exception {
 
     @Override
     protected void run() throws Exception {
-        Path temporalInputDir = Files.createDirectory(getOutDir().resolve(".input"));
+        Path temporalInputDir = Files.createDirectory(getOutDir().resolve(".opencga_input"));
         for (WorkflowScript script : workflow.getScripts()) {
             // Write script files
-            Files.write(temporalInputDir.resolve(script.getFileName()), script.getContent().getBytes());
-            inputBindings.add(new AbstractMap.SimpleEntry<>(temporalInputDir.resolve(script.getFileName()).toString(),
-                    inputDir.resolve(script.getFileName()).toString()));
+            Path path = temporalInputDir.resolve(script.getFileName());
+            Files.write(path, script.getContent().getBytes());
+            inputBindings.add(new AbstractMap.SimpleEntry<>(path.toString(), path.toString()));
         }
 
         // Write nextflow.config file
         URL nextflowConfig = getClass().getResource("/nextflow.config");
+        Path nextflowConfigPath;
         if (nextflowConfig != null) {
-            Files.copy(nextflowConfig.openStream(), temporalInputDir.resolve("nextflow.config"));
-            inputBindings.add(new AbstractMap.SimpleEntry<>(temporalInputDir.resolve("nextflow.config").toString(),
-                    inputDir.resolve("nextflow.config").toString()));
+            nextflowConfigPath = temporalInputDir.resolve("nextflow.config");
+            Files.copy(nextflowConfig.openStream(), nextflowConfigPath);
+            inputBindings.add(new AbstractMap.SimpleEntry<>(nextflowConfigPath.toString(), nextflowConfigPath.toString()));
         } else {
             throw new RuntimeException("Can't fetch nextflow.config file");
         }
 
+        String outDirPath = getOutDir().toAbsolutePath().toString();
 
-//        dockerParams.put("user", "0:0");
+        // Establish working directory
+        dockerParams.put("-w", outDirPath);
+        // Set HOME environment variable to the temporal input directory. This is because nextflow creates a hidden folder there and,
+        // when nextflow runs on other dockers, we need to store those files in a path shared between the parent docker and the host
+        dockerParams.put("-e", "HOME=" + temporalInputDir);
 
         // Build output binding
-        AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(getOutDir().toAbsolutePath().toString(),
-                outputDir);
+        AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(outDirPath, outDirPath);
 
-        String dockerImage = "nextflow/nextflow:" + workflow.getManager().getVersion();
+//        String dockerImage = "nextflow/nextflow:" + workflow.getManager().getVersion();
+        String dockerImage = "pfurio/nextflow";
         StringBuilder stringBuilder = new StringBuilder()
-                .append("bash -c \"nextflow -c ").append(inputDir).append("/nextflow.config").append(" run ");
+                .append("bash -c \"nextflow -c ").append(nextflowConfigPath).append(" run ");
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
-//            dockerParams.put("--volume", "/var/run/docker.sock:/var/run/docker.sock");
+            dockerParams.put("--volume", "/var/run/docker.sock:/var/run/docker.sock");
 //            dockerParams.put("--env", "DOCKER_HOST='tcp://localhost:2375'");
 //            dockerParams.put("--network", "host");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {
-                    stringBuilder.append(inputDir).append("/").append(script.getFileName());
+                    stringBuilder.append(temporalInputDir.resolve(script.getFileName()));
                     break;
                 }
             }
@@ -188,7 +194,7 @@ protected void run() throws Exception {
         if (StringUtils.isNotEmpty(cliParams)) {
             stringBuilder.append(" ").append(cliParams);
         }
-        stringBuilder.append(" -with-report ").append(outputDir).append("/report.html\"");
+        stringBuilder.append(" -with-report ").append(outDirPath).append("/report.html\"");
 //        // And give ownership permissions to the user running this process
 //        stringBuilder.append("; chown -R ")
 //                .append(UserProcessUtils.getUserUid()).append(":").append(UserProcessUtils.getGroupId()).append(" ").append(outputDir)
@@ -200,15 +206,15 @@ protected void run() throws Exception {
         StopWatch stopWatch = StopWatch.createStarted();
         DockerUtils.run(dockerImage, inputBindings, outputBinding, stringBuilder.toString(), dockerParams);
         logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
+        endTraceFileMonitor();
 
         // Delete input files and temporal directory
-        for (WorkflowScript script : workflow.getScripts()) {
-            Files.delete(temporalInputDir.resolve(script.getFileName()));
+        try (Stream<Path> paths = Files.walk(temporalInputDir)) {
+            paths.sorted(Comparator.reverseOrder())
+                    .map(Path::toFile)
+                    .forEach(java.io.File::delete);
         }
-        Files.delete(temporalInputDir.resolve("nextflow.config"));
-        Files.delete(temporalInputDir);
 
-        endTraceFileMonitor();
     }
 
     @Override

From 84782cb9de9224f6e74be62460d7072482bfe457 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 25 Sep 2024 19:55:41 +0200
Subject: [PATCH 60/99] analysis: add docker-host env, #TASK-6445

---
 .../opencb/opencga/analysis/workflow/NextFlowExecutor.java    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 4c1fed07976..31b75872fca 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -181,8 +181,8 @@ protected void run() throws Exception {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
             dockerParams.put("--volume", "/var/run/docker.sock:/var/run/docker.sock");
-//            dockerParams.put("--env", "DOCKER_HOST='tcp://localhost:2375'");
-//            dockerParams.put("--network", "host");
+            dockerParams.put("--env", "DOCKER_HOST='tcp://localhost:2375'");
+            dockerParams.put("--network", "host");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {

From ac5ec7b798f3970164c61c580efef8e19a95e5f6 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 26 Sep 2024 09:56:30 +0200
Subject: [PATCH 61/99] analysis: add dynamic output parameters, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java     | 17 ++++++++---------
 .../opencga/catalog/utils/InputFileUtils.java   | 12 ++++++++++++
 2 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 31b75872fca..652f2f97ab5 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -56,6 +56,7 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
     List<AbstractMap.SimpleEntry<String, String>> inputBindings;
 
     private Map<String, String> dockerParams;
+    private String outDirPath;
 
     private Thread thread;
     private final int monitorThreadPeriod = 5000;
@@ -92,6 +93,8 @@ protected void check() throws Exception {
             throw new ToolException("Workflow '" + nextflowParams.getId() + "' is null");
         }
 
+        outDirPath = getOutDir().toAbsolutePath().toString();
+
         // Update job tags and attributes
         ToolInfoExecutor toolInfoExecutor = new ToolInfoExecutor(workflow.getManager().getId().name(), workflow.getManager().getVersion());
         Set<String> tags = new HashSet<>();
@@ -111,13 +114,6 @@ protected void check() throws Exception {
 
             StringBuilder cliParamsBuilder = new StringBuilder();
             for (Map.Entry<String, String> entry : nextflowParams.getParams().entrySet()) {
-                if (entry.getKey().equalsIgnoreCase("dockerParams")) {
-                    Arrays.asList(entry.getValue().split(",")).forEach(s -> {
-                        String[] split = s.split("==");
-                        dockerParams.put(split[0], split[1]);
-                    });
-                    continue;
-                }
                 if (entry.getKey().startsWith("-")) {
                     cliParamsBuilder.append(entry.getKey()).append(" ");
                 } else {
@@ -128,7 +124,12 @@ protected void check() throws Exception {
                         File file = inputFileUtils.getOpenCGAFile(study, entry.getValue(), token);
                         String path = file.getUri().getPath();
                         inputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
+                        logger.debug("Params: OpenCGA input file: {}", path);
                         cliParamsBuilder.append(path).append(" ");
+                    } else if (inputFileUtils.isDynamicOutputFolder(entry.getValue())) {
+                        String dynamicOutputFolder = inputFileUtils.getDynamicOutputFolder(entry.getValue(), outDirPath);
+                        logger.debug("Params: Dynamic output folder: {}", dynamicOutputFolder);
+                        cliParamsBuilder.append(dynamicOutputFolder).append(" ");
                     } else {
                         cliParamsBuilder.append(entry.getValue()).append(" ");
                     }
@@ -162,8 +163,6 @@ protected void run() throws Exception {
             throw new RuntimeException("Can't fetch nextflow.config file");
         }
 
-        String outDirPath = getOutDir().toAbsolutePath().toString();
-
         // Establish working directory
         dockerParams.put("-w", outDirPath);
         // Set HOME environment variable to the temporal input directory. This is because nextflow creates a hidden folder there and,
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
index 6ed37259365..e92456fdf76 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
@@ -16,6 +16,7 @@ public class InputFileUtils {
     private final CatalogManager catalogManager;
 
     private static final Pattern OPERATION_PATTERN = Pattern.compile("^(?i)(ocga://|opencga://|file://)(.+)$");
+    private static final String OUTPUT = "$OUTPUT";
     private final Logger logger = LoggerFactory.getLogger(InputFileUtils.class);
 
     public InputFileUtils(CatalogManager catalogManager) {
@@ -43,4 +44,15 @@ public File getOpenCGAFile(String study, String file, String token) throws Catal
         return result.first();
     }
 
+    public boolean isDynamicOutputFolder(String file) {
+        return file.toUpperCase().startsWith(OUTPUT);
+    }
+
+    public String getDynamicOutputFolder(String file, String outDir) {
+        if (!isDynamicOutputFolder(file)) {
+            return file;
+        }
+        return outDir + file.substring(OUTPUT.length());
+    }
+
 }

From 416ee516ddb24d56d9327c04ab75e2bdf550c992 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 26 Sep 2024 17:45:41 +0200
Subject: [PATCH 62/99] app: add new nextflow dockerfile, #TASK-6445

---
 .../cloud/docker/opencga-nextflow/Dockerfile  | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 opencga-app/app/cloud/docker/opencga-nextflow/Dockerfile

diff --git a/opencga-app/app/cloud/docker/opencga-nextflow/Dockerfile b/opencga-app/app/cloud/docker/opencga-nextflow/Dockerfile
new file mode 100644
index 00000000000..f79fbce1260
--- /dev/null
+++ b/opencga-app/app/cloud/docker/opencga-nextflow/Dockerfile
@@ -0,0 +1,29 @@
+## Based on Ubuntu 22.04 (jammy)
+FROM eclipse-temurin:11.0.24_8-jre-jammy
+
+ARG BUILD_PATH="."
+
+RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpass ca-certificates curl gnupg jq unzip vim htop && \
+    ## Install Docker repository
+    install -m 0755 -d /etc/apt/keyrings && \
+    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg && \
+    chmod a+r /etc/apt/keyrings/docker.gpg && \
+    echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu "$(. /etc/os-release && echo "jammy")" stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null && \
+    apt-get update && apt-get install -y docker-ce docker-ce-cli containerd.io && \
+    ## Install yq
+    wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && \
+    chmod +x /usr/local/bin/yq && \
+    ## Install Nextflow \
+    curl -s https://get.nextflow.io | bash && \
+    chmod +xr nextflow && \
+    mv nextflow /usr/local/bin/ && \
+    ## Clean downloaded packages to make images smaller
+    rm -rf /var/lib/apt/lists/* && \
+    adduser --disabled-password --uid 1001 opencga && \
+    # Add docker group to opencga user
+    usermod -a -G docker opencga
+
+## Run Docker images as opencga user
+USER opencga
+
+WORKDIR /home/opencga

From 78c74eb0cee48335a7aa7630babdbc579924673c Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Fri, 27 Sep 2024 00:24:26 +0100
Subject: [PATCH 63/99] app: minor style improvements in opencga-base
 Dockerfile

---
 opencga-app/app/cloud/docker/opencga-base/Dockerfile | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/opencga-app/app/cloud/docker/opencga-base/Dockerfile b/opencga-app/app/cloud/docker/opencga-base/Dockerfile
index 35b25be2b02..03ea2a62635 100644
--- a/opencga-app/app/cloud/docker/opencga-base/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-base/Dockerfile
@@ -1,5 +1,4 @@
-## Based on Ubuntu 22.04 (jammy)
-## We are now using OpenJDK 8u372 to support "cgroup v2", see https://developers.redhat.com/articles/2023/04/19/openjdk-8u372-feature-cgroup-v2-support#
+## Based on Ubuntu 24.04 (noble)
 FROM eclipse-temurin:11.0.24_8-jre-noble
 
 ARG BUILD_PATH="."
@@ -13,18 +12,23 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpa
     curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg && \
     chmod a+r /etc/apt/keyrings/docker.gpg && \
     echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu "$(. /etc/os-release && echo "jammy")" stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null && \
+
     ## Install MongoDB 6.0 repository
     curl -fsSL https://pgp.mongodb.com/server-6.0.asc | gpg --dearmor -o /usr/share/keyrings/mongodb-server-6.0.gpg && \
     echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-6.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/6.0 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-6.0.list && \
-    ## Install docker and mongodb packages
+
+    ## Install Docker and MongoDB packages
     apt-get update && apt-get install -y docker-ce docker-ce-cli containerd.io mongodb-mongosh && \
+
     ## Install yq
     wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && \
     chmod +x /usr/local/bin/yq && \
+
     ## Install Nextflow \
     curl -s https://get.nextflow.io | bash && \
     chmod +xr nextflow && \
     mv nextflow /usr/local/bin/ && \
+
     ## Clean downloaded packages to make images smaller
     rm -rf /var/lib/apt/lists/* && \
     adduser --disabled-password --uid 1001 opencga

From 8739c18bf7ab8eb1e194326707d6b7845f4d9283 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Fri, 27 Sep 2024 09:08:57 +0100
Subject: [PATCH 64/99] app: add new opencga-workflow docker

---
 .github/workflows/manual-deploy-docker.yml    |  2 +-
 opencga-app/app/cloud/docker/docker-build.py  |  2 +-
 .../cloud/docker/opencga-workflow/Dockerfile  | 49 +++++++++++++++++++
 3 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 opencga-app/app/cloud/docker/opencga-workflow/Dockerfile

diff --git a/.github/workflows/manual-deploy-docker.yml b/.github/workflows/manual-deploy-docker.yml
index 3ee65923466..9b5ae04747e 100644
--- a/.github/workflows/manual-deploy-docker.yml
+++ b/.github/workflows/manual-deploy-docker.yml
@@ -55,5 +55,5 @@ jobs:
     uses: opencb/java-common-libs/.github/workflows/deploy-docker-hub-workflow.yml@develop
     needs: build
     with:
-      cli: python3 ./build/cloud/docker/docker-build.py push --images base,init --tag ${{ inputs.tag }}
+      cli: python3 ./build/cloud/docker/docker-build.py push --images base,init,workflow --tag ${{ inputs.tag }}
     secrets: inherit
diff --git a/opencga-app/app/cloud/docker/docker-build.py b/opencga-app/app/cloud/docker/docker-build.py
index 49459de914d..cf9fad92bea 100755
--- a/opencga-app/app/cloud/docker/docker-build.py
+++ b/opencga-app/app/cloud/docker/docker-build.py
@@ -11,7 +11,7 @@
 parser = argparse.ArgumentParser()
 parser.add_argument('action', help="Action to execute", choices=["build", "push", "delete"], default="build")
 parser.add_argument('--images',
-                    help="comma separated list of images to be made, e.g. base,init,ext-tools,r-builder")
+                    help="comma separated list of images to be made, e.g. base,workflow,init,ext-tools,r-builder")
 parser.add_argument('--tag', help="the tag for this code, e.g. v2.0.0-hdp3.1")
 parser.add_argument('--build-folder', help="the location of the build folder, if not default location")
 parser.add_argument('--org', help="Docker organization", default="opencb")
diff --git a/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile b/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
new file mode 100644
index 00000000000..7da00114f57
--- /dev/null
+++ b/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
@@ -0,0 +1,49 @@
+### Multi Stage building
+
+## 1. Based on Ubuntu 24.04 (noble)
+FROM eclipse-temurin:11.0.24_8-jre-noble AS base
+
+ARG BUILD_PATH="."
+
+ENV OPENCGA_HOME=/opt/opencga
+ENV OPENCGA_CONFIG_DIR=${OPENCGA_HOME}/conf
+
+RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpass ca-certificates curl gnupg jq unzip vim htop && \
+    ## Install Docker repository
+    install -m 0755 -d /etc/apt/keyrings && \
+    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg && \
+    chmod a+r /etc/apt/keyrings/docker.gpg && \
+    echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu "$(. /etc/os-release && echo "jammy")" stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null && \
+    apt-get update && apt-get install -y docker-ce docker-ce-cli containerd.io && \
+
+    ## Install yq
+    wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && \
+    chmod +x /usr/local/bin/yq && \
+
+    ## Install Nextflow \
+    curl -s https://get.nextflow.io | bash && \
+    chmod +xr nextflow && \
+    mv nextflow /usr/local/bin/ && \
+
+    ## Clean downloaded packages to make images smaller
+    rm -rf /var/lib/apt/lists/* && \
+    adduser --disabled-password --uid 1001 opencga && \
+
+    # Add docker group to opencga user
+    usermod -a -G docker opencga
+
+COPY --chown=opencga:opencga ${BUILD_PATH} /opt/opencga
+
+
+## 2. Based on base
+FROM base
+RUN apt-get install -y python3 python3-pip bcftools && \
+    pip3 install --break-system-packages /opt/opencga/clients/python && \
+    ## Clean downloaded packages to make images smaller
+    rm -rf /var/lib/apt/lists/*
+
+USER opencga
+## Declare the volume to be mounted later
+VOLUME /opt/opencga/conf
+
+WORKDIR /opt/opencga

From 9559215fea885ae9fd85ae92e13d01085f5606a5 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Fri, 27 Sep 2024 11:11:09 +0100
Subject: [PATCH 65/99] app: fixes in opencga-worklow docker

---
 opencga-app/app/cloud/docker/opencga-workflow/Dockerfile | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile b/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
index 7da00114f57..962a501987c 100644
--- a/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
@@ -8,13 +8,13 @@ ARG BUILD_PATH="."
 ENV OPENCGA_HOME=/opt/opencga
 ENV OPENCGA_CONFIG_DIR=${OPENCGA_HOME}/conf
 
-RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpass ca-certificates curl gnupg jq unzip vim htop && \
+RUN apt update && apt -y upgrade && apt install -y lsb-release sshpass ca-certificates curl gnupg jq unzip vim htop && \
     ## Install Docker repository
     install -m 0755 -d /etc/apt/keyrings && \
     curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg && \
     chmod a+r /etc/apt/keyrings/docker.gpg && \
     echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu "$(. /etc/os-release && echo "jammy")" stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null && \
-    apt-get update && apt-get install -y docker-ce docker-ce-cli containerd.io && \
+    apt update && apt install -y docker-ce docker-ce-cli containerd.io && \
 
     ## Install yq
     wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && \
@@ -29,7 +29,7 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpa
     rm -rf /var/lib/apt/lists/* && \
     adduser --disabled-password --uid 1001 opencga && \
 
-    # Add docker group to opencga user
+    ## Add docker group to opencga user
     usermod -a -G docker opencga
 
 COPY --chown=opencga:opencga ${BUILD_PATH} /opt/opencga
@@ -37,7 +37,7 @@ COPY --chown=opencga:opencga ${BUILD_PATH} /opt/opencga
 
 ## 2. Based on base
 FROM base
-RUN apt-get install -y python3 python3-pip bcftools && \
+RUN apt update && apt -y upgrade && apt install -y python3 python3-pip bcftools && \
     pip3 install --break-system-packages /opt/opencga/clients/python && \
     ## Clean downloaded packages to make images smaller
     rm -rf /var/lib/apt/lists/*

From f9fd34d2386aa942060c27b3bbfaa3adc9e121d0 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 27 Sep 2024 12:31:29 +0200
Subject: [PATCH 66/99] app: fix Dockerfile, #TASK-6445

---
 .../app/cloud/docker/opencga-workflow/Dockerfile   | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile b/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
index 7da00114f57..70a536079f8 100644
--- a/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
@@ -1,7 +1,7 @@
 ### Multi Stage building
 
-## 1. Based on Ubuntu 24.04 (noble)
-FROM eclipse-temurin:11.0.24_8-jre-noble AS base
+## 1. Based on Ubuntu 22.04 (jammy)
+FROM eclipse-temurin:11.0.24_8-jre-jammy AS base
 
 ARG BUILD_PATH="."
 
@@ -32,18 +32,18 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpa
     # Add docker group to opencga user
     usermod -a -G docker opencga
 
-COPY --chown=opencga:opencga ${BUILD_PATH} /opt/opencga
+COPY --chown=opencga:opencga ${BUILD_PATH} ${OPENCGA_HOME}
 
 
 ## 2. Based on base
 FROM base
-RUN apt-get install -y python3 python3-pip bcftools && \
-    pip3 install --break-system-packages /opt/opencga/clients/python && \
+RUN apt-get update && apt-get -y upgrade && apt-get install -y python3 python3-pip bcftools && \
+    pip3 install ${OPENCGA_HOME}/clients/python && \
     ## Clean downloaded packages to make images smaller
     rm -rf /var/lib/apt/lists/*
 
 USER opencga
 ## Declare the volume to be mounted later
-VOLUME /opt/opencga/conf
+VOLUME ${OPENCGA_CONFIG_DIR}
 
-WORKDIR /opt/opencga
+WORKDIR ${OPENCGA_HOME}

From fa96ec4718ee1dcd3734442e7230064d5b1137cf Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Fri, 27 Sep 2024 14:57:51 +0100
Subject: [PATCH 67/99] app: minor improvements

---
 .../cloud/docker/opencga-nextflow/Dockerfile  | 29 -------------------
 .../cloud/docker/opencga-workflow/Dockerfile  |  2 +-
 2 files changed, 1 insertion(+), 30 deletions(-)
 delete mode 100644 opencga-app/app/cloud/docker/opencga-nextflow/Dockerfile

diff --git a/opencga-app/app/cloud/docker/opencga-nextflow/Dockerfile b/opencga-app/app/cloud/docker/opencga-nextflow/Dockerfile
deleted file mode 100644
index f79fbce1260..00000000000
--- a/opencga-app/app/cloud/docker/opencga-nextflow/Dockerfile
+++ /dev/null
@@ -1,29 +0,0 @@
-## Based on Ubuntu 22.04 (jammy)
-FROM eclipse-temurin:11.0.24_8-jre-jammy
-
-ARG BUILD_PATH="."
-
-RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpass ca-certificates curl gnupg jq unzip vim htop && \
-    ## Install Docker repository
-    install -m 0755 -d /etc/apt/keyrings && \
-    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg && \
-    chmod a+r /etc/apt/keyrings/docker.gpg && \
-    echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu "$(. /etc/os-release && echo "jammy")" stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null && \
-    apt-get update && apt-get install -y docker-ce docker-ce-cli containerd.io && \
-    ## Install yq
-    wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && \
-    chmod +x /usr/local/bin/yq && \
-    ## Install Nextflow \
-    curl -s https://get.nextflow.io | bash && \
-    chmod +xr nextflow && \
-    mv nextflow /usr/local/bin/ && \
-    ## Clean downloaded packages to make images smaller
-    rm -rf /var/lib/apt/lists/* && \
-    adduser --disabled-password --uid 1001 opencga && \
-    # Add docker group to opencga user
-    usermod -a -G docker opencga
-
-## Run Docker images as opencga user
-USER opencga
-
-WORKDIR /home/opencga
diff --git a/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile b/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
index 70a536079f8..8a61e163331 100644
--- a/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-workflow/Dockerfile
@@ -37,7 +37,7 @@ COPY --chown=opencga:opencga ${BUILD_PATH} ${OPENCGA_HOME}
 
 ## 2. Based on base
 FROM base
-RUN apt-get update && apt-get -y upgrade && apt-get install -y python3 python3-pip bcftools && \
+RUN apt-get update && apt-get -y upgrade && apt-get install -y python3 python3-pip r-base samtools bcftools && \
     pip3 install ${OPENCGA_HOME}/clients/python && \
     ## Clean downloaded packages to make images smaller
     rm -rf /var/lib/apt/lists/*

From 16f35e7b0122e1b57dbc4f37064448c20094cc7e Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 27 Sep 2024 17:00:31 +0200
Subject: [PATCH 68/99] catalog: explore file content to find file:// prefixes,
 #TASK-6445

---
 .../customTool/CustomToolExecutor.java        |  2 +-
 .../analysis/workflow/NextFlowExecutor.java   | 33 ++++++---
 .../analysis/tools/WorkflowExecutorTest.java  | 17 ++++-
 .../opencga/catalog/managers/FileManager.java |  2 +-
 .../opencga/catalog/managers/JobManager.java  |  4 +-
 .../opencga/catalog/utils/InputFileUtils.java | 68 ++++++++++++++++---
 .../src/main/resources/catalog-indexes.txt    |  2 +-
 7 files changed, 104 insertions(+), 24 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
index e22c8ffa3f1..c6dd60bc323 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
@@ -75,7 +75,7 @@ protected void check() throws Exception {
         Map<String, String> inputDirectoryMounts = new HashMap<>();
         for (String param : params) {
             if (inputFileUtils.isValidOpenCGAFile(param)) {
-                File file = inputFileUtils.getOpenCGAFile(study, param, token);
+                File file = inputFileUtils.findOpenCGAFileFromPattern(study, param, token);
                 Path parent = Paths.get(file.getUri()).getParent();
                 if (!inputDirectoryMounts.containsKey(parent.toString())) {
                     inputDirectoryMounts.put(parent.toString(), "/data/input" + inputDirectoryMounts.size());
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 652f2f97ab5..40d0dc26bc1 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -55,6 +55,7 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
     // Build list of inputfiles in case we need to specifically mount them in read only mode
     List<AbstractMap.SimpleEntry<String, String>> inputBindings;
 
+    private Path temporalInputDir;
     private Map<String, String> dockerParams;
     private String outDirPath;
 
@@ -75,6 +76,7 @@ protected void check() throws Exception {
         }
 
         dockerParams = new HashMap<>();
+        temporalInputDir = Files.createDirectory(getOutDir().resolve(".opencga_input"));
 
         OpenCGAResult<Workflow> result;
         if (nextflowParams.getVersion() != null) {
@@ -105,7 +107,7 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
-        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
+//        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
 
         this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
@@ -121,14 +123,30 @@ protected void check() throws Exception {
                 }
                 if (StringUtils.isNotEmpty(entry.getValue())) {
                     if (inputFileUtils.isValidOpenCGAFile(entry.getValue())) {
-                        File file = inputFileUtils.getOpenCGAFile(study, entry.getValue(), token);
-                        String path = file.getUri().getPath();
-                        inputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
-                        logger.debug("Params: OpenCGA input file: {}", path);
-                        cliParamsBuilder.append(path).append(" ");
+                        File file = inputFileUtils.findOpenCGAFileFromPattern(study, entry.getValue(), token);
+                        if (inputFileUtils.fileMayContainReferencesToOtherFiles(file)) {
+                            Path outputFile = temporalInputDir.resolve(file.getName());
+                            List<File> files = inputFileUtils.findAndReplaceFilePathToUrisFromFile(study, file, outputFile, token);
+
+                            // Write outputFile as inputBinding
+                            inputBindings.add(new AbstractMap.SimpleEntry<>(outputFile.toString(), outputFile.toString()));
+                            logger.info("Params: OpenCGA input file: {}", outputFile);
+                            cliParamsBuilder.append(outputFile).append(" ");
+
+                            // Add files to inputBindings to ensure they are also mounted (if any)
+                            for (File tmpFile : files) {
+                                inputBindings.add(new AbstractMap.SimpleEntry<>(tmpFile.getUri().getPath(), tmpFile.getUri().getPath()));
+                                logger.info("Inner files from '{}': OpenCGA input file: '{}'", outputFile, tmpFile.getUri().getPath());
+                            }
+                        } else {
+                            String path = file.getUri().getPath();
+                            inputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
+                            logger.info("Params: OpenCGA input file: {}", path);
+                            cliParamsBuilder.append(path).append(" ");
+                        }
                     } else if (inputFileUtils.isDynamicOutputFolder(entry.getValue())) {
                         String dynamicOutputFolder = inputFileUtils.getDynamicOutputFolder(entry.getValue(), outDirPath);
-                        logger.debug("Params: Dynamic output folder: {}", dynamicOutputFolder);
+                        logger.info("Params: Dynamic output folder: {}", dynamicOutputFolder);
                         cliParamsBuilder.append(dynamicOutputFolder).append(" ");
                     } else {
                         cliParamsBuilder.append(entry.getValue()).append(" ");
@@ -144,7 +162,6 @@ protected void check() throws Exception {
 
     @Override
     protected void run() throws Exception {
-        Path temporalInputDir = Files.createDirectory(getOutDir().resolve(".opencga_input"));
         for (WorkflowScript script : workflow.getScripts()) {
             // Write script files
             Path path = temporalInputDir.resolve(script.getFileName());
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index 8379877b820..d26f1362434 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -83,15 +83,26 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         WorkflowCreateParams workflow = new WorkflowCreateParams()
                 .setId("workflow")
                 .setType(Workflow.Type.OTHER)
-//                .setCommandLine("run nextflow-io/rnaseq-nf -with-docker");
-                .setRepository(new WorkflowRepository("nextflow-io/rnaseq-nf"));
+                .setRepository(new WorkflowRepository("nf-core/demo"));
         catalogManager.getWorkflowManager().create(studyFqn, workflow.toWorkflow(), QueryOptions.empty(), ownerToken);
 
+        catalogManager.getFileManager().create(studyFqn, new FileCreateParams()
+                .setPath("samplesheet.csv")
+                .setContent("sample,fastq_1,fastq_2\n" +
+                        "SAMPLE3_SE,https://raw.githubusercontent.com/nf-core/test-datasets/viralrecon/illumina/amplicon/sample1_R1.fastq.gz,ocga://samplesheet.csv file://samplesheet.csv hello opencga://samplesheet.csv\n" +
+                        "SAMPLE3_SE,https://raw.githubusercontent.com/nf-core/test-datasets/viralrecon/illumina/amplicon/sample2_R1.fastq.gz,")
+                .setType(File.Type.FILE), false, ownerToken);
+
         Path outDir = Paths.get(catalogManagerResource.createTmpOutdir("_nextflow"));
 
         StopWatch stopWatch = StopWatch.createStarted();
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
-        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1, Collections.emptyMap());
+        Map<String, String> cliParams = new HashMap<>();
+        cliParams.put("input", "file://samplesheet.csv");
+        cliParams.put("outdir", "$OUTPUT");
+        cliParams.put("genome", "GRCh37");
+        cliParams.put("-profile", "docker");
+        NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1, cliParams);
         ObjectMap params = runParams.toObjectMap();
         params.put(ParamConstants.STUDY_PARAM, studyFqn);
         nextFlowExecutorTest.setUp(catalogManagerResource.getOpencgaHome().toString(), catalogManager,
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/FileManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/FileManager.java
index 37be3aeeba2..c037a3ed385 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/FileManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/FileManager.java
@@ -108,7 +108,7 @@ public class FileManager extends AnnotationSetManager<File> {
                 FileDBAdaptor.QueryParams.NAME.key(), FileDBAdaptor.QueryParams.UID.key(), FileDBAdaptor.QueryParams.UUID.key(),
                 FileDBAdaptor.QueryParams.INTERNAL_STATUS.key(), FileDBAdaptor.QueryParams.FORMAT.key(),
                 FileDBAdaptor.QueryParams.URI.key(), FileDBAdaptor.QueryParams.PATH.key(), FileDBAdaptor.QueryParams.EXTERNAL.key(),
-                FileDBAdaptor.QueryParams.STUDY_UID.key(), FileDBAdaptor.QueryParams.TYPE.key()));
+                FileDBAdaptor.QueryParams.STUDY_UID.key(), FileDBAdaptor.QueryParams.TYPE.key(), FileDBAdaptor.QueryParams.SIZE.key()));
         EXCLUDE_FILE_ATTRIBUTES = new QueryOptions(QueryOptions.EXCLUDE, Arrays.asList(FileDBAdaptor.QueryParams.ATTRIBUTES.key(),
                 FileDBAdaptor.QueryParams.ANNOTATION_SETS.key(), FileDBAdaptor.QueryParams.STATS.key()));
         INCLUDE_STUDY_URI = new QueryOptions(QueryOptions.INCLUDE, StudyDBAdaptor.QueryParams.URI.key());
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
index 8bbafa9d7d9..bf335ff1302 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
@@ -492,7 +492,7 @@ public List<File> getWorkflowJobInputFilesFromParams(String study, Job job, Stri
                     String fileStr = (String) entry.getValue();
                     if (inputFileUtils.isValidOpenCGAFile(fileStr)) {
                         try {
-                            File file = inputFileUtils.getOpenCGAFile(study, fileStr, token);
+                            File file = inputFileUtils.findOpenCGAFileFromPattern(study, fileStr, token);
                             inputFiles.add(file);
                         } catch (CatalogException e) {
                             throw new CatalogException("Cannot find file '" + entry.getValue() + "' from job param '" + entry.getKey()
@@ -507,7 +507,7 @@ public List<File> getWorkflowJobInputFilesFromParams(String study, Job job, Stri
                             String fileStr = (String) subEntry.getValue();
                             if (inputFileUtils.isValidOpenCGAFile(fileStr)) {
                                 try {
-                                    File file = inputFileUtils.getOpenCGAFile(study, fileStr, token);
+                                    File file = inputFileUtils.findOpenCGAFileFromPattern(study, fileStr, token);
                                     inputFiles.add(file);
                                 } catch (CatalogException e) {
                                     throw new CatalogException("Cannot find file '" + subEntry.getValue() + "' from variable '"
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
index e92456fdf76..f19f20be8aa 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
@@ -8,6 +8,11 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.*;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -15,7 +20,8 @@ public class InputFileUtils {
 
     private final CatalogManager catalogManager;
 
-    private static final Pattern OPERATION_PATTERN = Pattern.compile("^(?i)(ocga://|opencga://|file://)(.+)$");
+    private static final Pattern OPENCGA_PATH_PATTERN = Pattern.compile("^(?i)(ocga://|opencga://|file://)(.+)$");
+    private static final Pattern OPENCGA_PATH_IN_LINE_PATTERN = Pattern.compile("(?i)(ocga://|opencga://|file://)(\\S+)");
     private static final String OUTPUT = "$OUTPUT";
     private final Logger logger = LoggerFactory.getLogger(InputFileUtils.class);
 
@@ -23,27 +29,73 @@ public InputFileUtils(CatalogManager catalogManager) {
         this.catalogManager = catalogManager;
     }
 
-    public boolean isValidOpenCGAFile(String file) {
-        return OPERATION_PATTERN.matcher(file).matches();
+    public boolean isValidOpenCGAFile(String content) {
+        return OPENCGA_PATH_PATTERN.matcher(content).matches();
     }
 
-    public File getOpenCGAFile(String study, String file, String token) throws CatalogException {
-        Matcher matcher = OPERATION_PATTERN.matcher(file);
-
+    public File findOpenCGAFileFromPattern(String study, String content, String token) throws CatalogException {
+        Matcher matcher = OPENCGA_PATH_PATTERN.matcher(content);
         if (!matcher.find()) {
             throw new CatalogException("Invalid OpenCGA file format. Accepted format is 'ocga://<path>', 'opencga://<path>' or"
                     + " 'file://<path>'.");
         }
+        return getOpenCGAFile(study, matcher.group(2), token);
+    }
 
-        String filePath = matcher.group(2);
+    private File getOpenCGAFile(String study, String filePath, String token) throws CatalogException {
         logger.info("Looking for file '{}'", filePath);
         OpenCGAResult<File> result = catalogManager.getFileManager().get(study, filePath, FileManager.INCLUDE_FILE_URI_PATH, token);
         if (result.getNumResults() == 0) {
-            throw new CatalogException("File '" + file + "' not found in study '" + study + "'");
+            throw new CatalogException("File '" + filePath + "' not found in study '" + study + "'");
         }
         return result.first();
     }
 
+    public boolean fileMayContainReferencesToOtherFiles(File file) {
+        // Check file size is smaller than 10MB
+        return file.getSize() < 10 * 1024 * 1024;
+    }
+
+    public List<File> findAndReplaceFilePathToUrisFromFile(String study, File file, Path outFile, String token) throws CatalogException {
+        BufferedReader br = null;
+        BufferedWriter bw = null;
+
+        List<File> fileList = new LinkedList<>();
+        try {
+            br = new BufferedReader(new FileReader(Paths.get(file.getUri()).toFile()));
+            bw = new BufferedWriter(new FileWriter(outFile.toFile()));
+            String line;
+            while ((line = br.readLine()) != null) {
+                Matcher matcher = OPENCGA_PATH_IN_LINE_PATTERN.matcher(line);
+                while (matcher.find()) {
+                    File tmpFile = getOpenCGAFile(study, matcher.group(2), token);
+                    fileList.add(tmpFile);
+                    line = matcher.replaceFirst(tmpFile.getUri().getPath());
+                    matcher = OPENCGA_PATH_IN_LINE_PATTERN.matcher(line);
+                }
+                bw.write(line + "\n");
+            }
+        } catch (Exception e) {
+            throw new CatalogException(e);
+        } finally {
+            try {
+                if (br != null) {
+                    br.close();
+                }
+            } catch (IOException e) {
+                throw new CatalogException(e);
+            }
+            try {
+                if (bw != null) {
+                    bw.close();
+                }
+            } catch (IOException e) {
+                throw new CatalogException(e);
+            }
+        }
+        return fileList;
+    }
+
     public boolean isDynamicOutputFolder(String file) {
         return file.toUpperCase().startsWith(OUTPUT);
     }
diff --git a/opencga-catalog/src/main/resources/catalog-indexes.txt b/opencga-catalog/src/main/resources/catalog-indexes.txt
index 7710a8ce03a..fc634c31838 100644
--- a/opencga-catalog/src/main/resources/catalog-indexes.txt
+++ b/opencga-catalog/src/main/resources/catalog-indexes.txt
@@ -28,7 +28,7 @@
 {"collections": ["job"], "fields": {"output.uid": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"priority": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"tags": 1, "studyUid": 1}, "options": {}}
-{"collections": ["job"], "fields": {"dryRun: 1, "studyUid": 1}, "options": {}}
+{"collections": ["job"], "fields": {"dryRun": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"visited": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"internal.status.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"internal.status.id": 1, "_priority": 1, "_creationDate": 1}, "options": {}}

From d9c153c9e88a2fbe4e519bfb165b60d57121a507 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sat, 28 Sep 2024 18:20:02 +0100
Subject: [PATCH 69/99] app: remove Nextflow from opencga-base Dockerfile

---
 opencga-app/app/cloud/docker/opencga-base/Dockerfile | 9 ++-------
 1 file changed, 2 insertions(+), 7 deletions(-)

diff --git a/opencga-app/app/cloud/docker/opencga-base/Dockerfile b/opencga-app/app/cloud/docker/opencga-base/Dockerfile
index 03ea2a62635..0a5a8bf794b 100644
--- a/opencga-app/app/cloud/docker/opencga-base/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-base/Dockerfile
@@ -1,5 +1,5 @@
-## Based on Ubuntu 24.04 (noble)
-FROM eclipse-temurin:11.0.24_8-jre-noble
+## Based on Ubuntu 22.04 (jammy)
+FROM eclipse-temurin:11.0.24_8-jre-jammy
 
 ARG BUILD_PATH="."
 
@@ -24,11 +24,6 @@ RUN apt-get update && apt-get -y upgrade && apt-get install -y lsb-release sshpa
     wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 && \
     chmod +x /usr/local/bin/yq && \
 
-    ## Install Nextflow \
-    curl -s https://get.nextflow.io | bash && \
-    chmod +xr nextflow && \
-    mv nextflow /usr/local/bin/ && \
-
     ## Clean downloaded packages to make images smaller
     rm -rf /var/lib/apt/lists/* && \
     adduser --disabled-password --uid 1001 opencga

From 95eee7c6ae6ebf1f6080683061b89bfcdbd7efce Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Sat, 28 Sep 2024 18:46:59 +0100
Subject: [PATCH 70/99] cdcd: add opencga-workflow docker to the different GH
 Actions workflows

---
 .github/workflows/develop.yml              | 2 +-
 .github/workflows/manual-deploy-docker.yml | 2 +-
 .github/workflows/pull-request-merged.yml  | 2 +-
 .github/workflows/release.yml              | 2 +-
 .github/workflows/task.yml                 | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/develop.yml b/.github/workflows/develop.yml
index 00f6aa9fa53..cc3c57e82a0 100644
--- a/.github/workflows/develop.yml
+++ b/.github/workflows/develop.yml
@@ -32,5 +32,5 @@ jobs:
     uses: opencb/java-common-libs/.github/workflows/deploy-docker-hub-workflow.yml@develop
     needs: build
     with:
-      cli: python3 ./build/cloud/docker/docker-build.py push --images base,init
+      cli: python3 ./build/cloud/docker/docker-build.py push --images base,workflow,init
     secrets: inherit
diff --git a/.github/workflows/manual-deploy-docker.yml b/.github/workflows/manual-deploy-docker.yml
index 9b5ae04747e..babf29285c5 100644
--- a/.github/workflows/manual-deploy-docker.yml
+++ b/.github/workflows/manual-deploy-docker.yml
@@ -55,5 +55,5 @@ jobs:
     uses: opencb/java-common-libs/.github/workflows/deploy-docker-hub-workflow.yml@develop
     needs: build
     with:
-      cli: python3 ./build/cloud/docker/docker-build.py push --images base,init,workflow --tag ${{ inputs.tag }}
+      cli: python3 ./build/cloud/docker/docker-build.py push --images base,workflow,init --tag ${{ inputs.tag }}
     secrets: inherit
diff --git a/.github/workflows/pull-request-merged.yml b/.github/workflows/pull-request-merged.yml
index 24906414101..ccb9dc1c829 100644
--- a/.github/workflows/pull-request-merged.yml
+++ b/.github/workflows/pull-request-merged.yml
@@ -19,6 +19,6 @@ jobs:
     uses: opencb/java-common-libs/.github/workflows/delete-docker-hub-workflow.yml@develop
     needs: build
     with:
-      cli: python3 ./build/cloud/docker/docker-build.py delete --images base --tag ${{ github.head_ref }}
+      cli: python3 ./build/cloud/docker/docker-build.py delete --images base,workflow --tag ${{ github.head_ref }}
     secrets: inherit
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index b59c92125e0..965f4f9d0a2 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -19,7 +19,7 @@ jobs:
     uses: opencb/java-common-libs/.github/workflows/deploy-docker-hub-workflow.yml@develop
     needs: build-hdp
     with:
-      cli: python3 ./build/cloud/docker/docker-build.py push --images base,init --tag "${{ needs.build-hdp.outputs.version }}-hdp3.1"
+      cli: python3 ./build/cloud/docker/docker-build.py push --images base,workflow,init --tag "${{ needs.build-hdp.outputs.version }}-hdp3.1"
       build_folder: build-folder
     secrets: inherit
 
diff --git a/.github/workflows/task.yml b/.github/workflows/task.yml
index 496e45ac6d7..c610fa3ac02 100644
--- a/.github/workflows/task.yml
+++ b/.github/workflows/task.yml
@@ -25,5 +25,5 @@ jobs:
     uses: opencb/java-common-libs/.github/workflows/deploy-docker-hub-workflow.yml@develop
     needs: test
     with:
-      cli: python3 ./build/cloud/docker/docker-build.py push --images base --tag ${{ github.ref_name }}
+      cli: python3 ./build/cloud/docker/docker-build.py push --images base,workflow --tag ${{ github.ref_name }}
     secrets: inherit

From 31ed1c0046ff524a1abf5ee07fd8fc5aa49bd35e Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Mon, 30 Sep 2024 02:02:22 +0100
Subject: [PATCH 71/99] Adding a new variant tool to liftover VCF files

---
 .../liftover/LiftoverWrapperAnalysis.java     | 71 +++++++++++++++++
 .../LiftoverWrapperAnalysisExecutor.java      | 62 +++++++++++++++
 opencga-app/app/analysis/liftover/liftover.sh | 78 +++++++++++++++++++
 .../cloud/docker/opencga-ext-tools/Dockerfile | 63 +++++++++++----
 .../app/cli/main/OpenCgaCompleter.java        |  2 +-
 .../app/cli/main/OpencgaCliOptionsParser.java |  1 +
 .../AnalysisVariantCommandExecutor.java       | 45 +++++++++++
 .../AnalysisVariantCommandOptions.java        | 49 ++++++++++++
 opencga-client/src/main/R/R/Variant-methods.R | 15 ++++
 .../client/rest/clients/VariantClient.java    | 23 ++++++
 opencga-client/src/main/javascript/Variant.js | 19 +++++
 .../pyopencga/rest_clients/variant_client.py  | 24 ++++++
 .../models/variant/LiftoverWrapperParams.java | 74 ++++++++++++++++++
 .../rest/analysis/VariantWebService.java      | 17 ++++
 14 files changed, 529 insertions(+), 14 deletions(-)
 create mode 100644 opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysis.java
 create mode 100644 opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysisExecutor.java
 create mode 100644 opencga-app/app/analysis/liftover/liftover.sh
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/variant/LiftoverWrapperParams.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysis.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysis.java
new file mode 100644
index 00000000000..81caf856e8a
--- /dev/null
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysis.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2015-2020 OpenCB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opencb.opencga.analysis.wrappers.liftover;
+
+
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
+import org.opencb.opencga.analysis.variant.manager.CatalogUtils;
+import org.opencb.opencga.analysis.wrappers.plink.PlinkWrapperAnalysisExecutor;
+import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.variant.LiftoverWrapperParams;
+import org.opencb.opencga.core.tools.annotations.Tool;
+import org.opencb.opencga.core.tools.annotations.ToolParams;
+
+@Tool(id = LiftoverWrapperAnalysis.ID, resource = Enums.Resource.VARIANT, description = LiftoverWrapperAnalysis.DESCRIPTION)
+public class LiftoverWrapperAnalysis extends OpenCgaToolScopeStudy {
+
+    public final static String ID = "liftover";
+    public static final String DESCRIPTION = "BCFtools liftover plugin maps coordinates from assembly 37 to 38.";
+
+    @ToolParams
+    protected final LiftoverWrapperParams analysisParams = new LiftoverWrapperParams();
+
+    protected void check() throws Exception {
+        super.check();
+
+        if (StringUtils.isEmpty(analysisParams.getFile())) {
+            throw new ToolException("Liftover 'file' parameter is mandatory.");
+        }
+
+        if (StringUtils.isEmpty(analysisParams.getOutdir())) {
+            String file = analysisParams.getFile();
+            if (file.contains("/")) {
+                analysisParams.setOutdir(file.substring(0, file.lastIndexOf('/')));
+            } else {
+                analysisParams.setOutdir("");
+            }
+        }
+    }
+
+    @Override
+    protected void run() throws Exception {
+//        setUpStorageEngineExecutor(study);
+
+        step(() -> {
+            executorParams.append("study", study);
+            executorParams.append("file", analysisParams.getFile());
+            executorParams.append("targetAssembly", analysisParams.getTargetAssembly());
+            executorParams.append("outdir", analysisParams.getOutdir());
+
+            getToolExecutor(LiftoverWrapperAnalysisExecutor.class)
+                    .execute();
+        });
+    }
+}
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysisExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysisExecutor.java
new file mode 100644
index 00000000000..0902de118f2
--- /dev/null
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysisExecutor.java
@@ -0,0 +1,62 @@
+package org.opencb.opencga.analysis.wrappers.liftover;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+import org.opencb.opencga.analysis.wrappers.executors.DockerWrapperAnalysisExecutor;
+import org.opencb.opencga.analysis.wrappers.plink.PlinkWrapperAnalysis;
+import org.opencb.opencga.core.tools.annotations.ToolExecutor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.*;
+
+@ToolExecutor(id = LiftoverWrapperAnalysisExecutor.ID,
+        tool = LiftoverWrapperAnalysis.ID,
+        source = ToolExecutor.Source.FILE,
+        framework = ToolExecutor.Framework.LOCAL)
+public class LiftoverWrapperAnalysisExecutor extends DockerWrapperAnalysisExecutor {
+
+    public final static String ID = LiftoverWrapperAnalysis.ID + "-local";
+
+    private String study;
+
+    private Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @Override
+    protected void run() throws Exception {
+        StringBuilder sb = initCommandLine();
+
+        // Append mounts
+        List<Pair<String, String>> inputFilenames = DockerWrapperAnalysisExecutor.getInputFilenames(null,
+                PlinkWrapperAnalysis.FILE_PARAM_NAMES, getExecutorParams());
+        Map<String, String> mountMap = appendMounts(inputFilenames, sb);
+
+        // Append docker image, version and command
+        appendCommand("bcftools +liftover", sb);
+
+        // Append input file params
+        appendInputFiles(inputFilenames, mountMap, sb);
+
+        // Append output file params
+        List<Pair<String, String>> outputFilenames = new ArrayList<>(Arrays.asList(new ImmutablePair<>("out", "")));
+        appendOutputFiles(outputFilenames, sb);
+
+        // Append other params
+        Set<String> skipParams =  new HashSet<>(Arrays.asList("out", "noweb"));
+        skipParams.addAll(PlinkWrapperAnalysis.FILE_PARAM_NAMES);
+        appendOtherParams(skipParams, sb);
+
+        // Execute command and redirect stdout and stderr to the files
+        logger.info("Docker command line: " + sb.toString());
+        runCommandLine(sb.toString());
+    }
+
+    public String getStudy() {
+        return study;
+    }
+
+    public LiftoverWrapperAnalysisExecutor setStudy(String study) {
+        this.study = study;
+        return this;
+    }
+}
diff --git a/opencga-app/app/analysis/liftover/liftover.sh b/opencga-app/app/analysis/liftover/liftover.sh
new file mode 100644
index 00000000000..b737186a5cb
--- /dev/null
+++ b/opencga-app/app/analysis/liftover/liftover.sh
@@ -0,0 +1,78 @@
+#
+# Copyright 2015-2020 OpenCB
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+#/bin/bash
+
+INPUT_FILE=$1
+TARGET_ASSEMBLY=$2
+OUTPUT_FILE=$3
+
+if [ -z "$INPUT_FILE" ] || [ -z "$TARGET_ASSEMBLY" ] || [ -z "$OUTPUT_FILE" ]; then
+    echo "Usage: $0 <source_assembly> <target_assembly>"
+    exit 1
+fi
+
+if [ $TARGET_ASSEMBLY == "GRCh38" ]; then
+    echo "Liftover from GRCh37 to $TARGET_ASSEMBLY"
+
+    ## Prepare GRCh37 and GRCh38 reference genomes
+    if [ ! -f Homo_sapiens.GRCh37.dna.primary_assembly.fa.gz ]; then
+      wget --no-check-certificate https://resources.opencb.org/opencb/opencga/analysis/commons/reference-genomes/Homo_sapiens.GRCh37.dna.primary_assembly.fa.gz
+    fi
+
+    if [ ! -f Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz ]; then
+      wget --no-check-certificate https://resources.opencb.org/opencb/opencga/analysis/commons/reference-genomes/Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz
+    fi
+
+    gunzip Homo_sapiens.GRCh37.dna.primary_assembly.fa.gz
+    SOURCE_REFERENCE_FILE="Homo_sapiens.GRCh37.dna.primary_assembly.fa"
+
+    gunzip Homo_sapiens.GRCh38.dna.primary_assembly.fa.gz
+    TARGET_REFERENCE_FILE="Homo_sapiens.GRCh38.dna.primary_assembly.fa"
+
+    wget http://ftp.ensembl.org/pub/assembly_mapping/homo_sapiens/GRCh37_to_GRCh38.chain.gz
+    CHAIN_FILE="GRCh37_to_GRCh38.chain.gz"
+elif [ $TARGET_ASSEMBLY == "hg38" ]; then
+    echo "Liftover from hg19 to $TARGET_ASSEMBLY"
+
+    ## Prepare hg19 and hg38 reference genomes
+    if [ ! -f hg19.fa.gz ]; then
+      wget https://hgdownload.soe.ucsc.edu/goldenPath/hg19/bigZips/hg19.fa.gz
+    fi
+
+    if [ ! -f hg38.fa.gz ]; then
+      wget https://hgdownload.soe.ucsc.edu/goldenPath/hg38/bigZips/hg38.fa.gz
+    fi
+
+    gunzip hg19.fa.gz
+    SOURCE_REFERENCE_FILE="hg19.fa"
+
+    gunzip hg38.fa.gz
+    TARGET_REFERENCE_FILE="hg38.fa"
+
+    wget http://hgdownload.cse.ucsc.edu/goldenpath/hg19/liftOver/hg19ToHg38.over.chain.gz
+    CHAIN_FILE="hg19ToHg38.over.chain.gz"
+else
+    echo "Unsupported target assembly $TARGET_ASSEMBLY"
+    exit 1
+fi
+
+## Execute bcftools
+bcftools +liftover --no-version -Oz $INPUT_FILE -- -s $SOURCE_REFERENCE_FILE -f $TARGET_REFERENCE_FILE -c $CHAIN_FILE --reject rejected.vcf --reject-type v --write-reject --write-src > $OUTPUT_FILE
+
+## Clean folders
+rm *.fai
+rm *.chain.gz
\ No newline at end of file
diff --git a/opencga-app/app/cloud/docker/opencga-ext-tools/Dockerfile b/opencga-app/app/cloud/docker/opencga-ext-tools/Dockerfile
index ab261b25c2f..a01df67c0ff 100644
--- a/opencga-app/app/cloud/docker/opencga-ext-tools/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-ext-tools/Dockerfile
@@ -7,31 +7,68 @@ LABEL org.label-schema.vendor="OpenCB" \
       maintainer="Joaquin Tarraga <joaquintarraga@gmail.com>" \
       org.label-schema.schema-version="1.0"
 
-WORKDIR /opt/opencga/signature.tools.lib
+# WORKDIR /opt/opencga/signature.tools.lib
 
 # run update and install necessary packages
-RUN apt-get update -y && DEBIAN_FRONTEND="noninteractive" TZ="Europe/London" apt-get install -y \
-    libcurl4 git libgmp-dev libcurl4-openssl-dev libgit2-dev libssl-dev libssh-dev libxml2-dev libfontconfig1-dev libharfbuzz-dev libfribidi-dev \
-    libfreetype6-dev libpng-dev libtiff5-dev libjpeg-dev \
+RUN apt-get update -y && \
+    ## 1. Install system dependencies
+    DEBIAN_FRONTEND="noninteractive" TZ="Europe/London" apt-get install -y libcurl4 git libgmp-dev libcurl4-openssl-dev libgit2-dev \
+    libssl-dev libssh-dev libxml2-dev libfontconfig1-dev libharfbuzz-dev libfribidi-dev libfreetype6-dev libpng-dev libtiff5-dev libjpeg-dev \
     gnuplot pandoc samtools bcftools tabix fastqc plink1.9 bwa r-base && \
-    ## Installation dependencies using R install.packages() is slower than apt-get but final size is 400GB smaller.
+
+    ## 2. Install samtools and bcftools 1.21 and plugins
+    wget https://github.com/samtools/samtools/releases/download/1.21/samtools-1.21.tar.bz2 && \
+    tar xjvf samtools-1.21.tar.bz2 && \
+    cd samtools-1.21 && \
+    ./configure --prefix=/usr/local/bin && \
+    make && make install && \
+    cd .. && \
+
+    wget http://github.com/samtools/bcftools/releases/download/1.21/bcftools-1.21.tar.bz2 && \
+    tar xjvf bcftools-1.21.tar.bz2 && \
+    wget -P bcftools-1.21 http://raw.githubusercontent.com/DrTimothyAldenDavis/SuiteSparse/stable/{SuiteSparse_config/SuiteSparse_config,CHOLMOD/Include/cholmod}.h && \
+    cd bcftools-1.21/ && \
+    /bin/rm -f plugins/{score.{c,h},{munge,liftover,metal,blup}.c,pgs.{c,mk}} && \
+    wget -P plugins http://raw.githubusercontent.com/freeseek/score/master/{score.{c,h},{munge,liftover,metal,blup}.c,pgs.{c,mk}} && \
+    make && \
+    /bin/cp bcftools plugins/{munge,liftover,score,metal,pgs,blup}.so /usr/local/bin/ && \
+    wget -P /usr/local/bin http://raw.githubusercontent.com/freeseek/score/master/assoc_plot.R && \
+    chmod a+x /usr/local/bin/assoc_plot.R && \
+    cd .. && \
+
+    ## 3. Installation dependencies using R install.packages() is slower than apt-get but final size is 400MB smaller.
     R -e "install.packages(c('BiocManager', 'RCircos', 'nnls', 'ggplot2', 'jsonlite', 'optparse', 'knitr', 'configr', 'dplyr', 'rmarkdown', 'tidyr', 'httr', 'kinship2', 'limSolve'))" && \
     R -e "BiocManager::install('BiocStyle')" && \
     R -e "BiocManager::install('BSgenome.Hsapiens.UCSC.hg38')" && \
-    ## signature.tools.lib installation \
-    R -e 'install.packages(c("devtools", "getopt"), repos=c("http://cran.rstudio.com/", "https://www.stats.bris.ac.uk/R/"))' && \
-    git clone https://github.com/Nik-Zainal-Group/signature.tools.lib.git /opt/opencga/signature.tools.lib
-
-WORKDIR /opt/opencga/signature.tools.lib
 
-RUN git fetch origin --tags && \
+    ## 4. Install signature.tools.lib installation \
+    R -e 'install.packages(c("devtools", "getopt"), repos=c("http://cran.rstudio.com/", "https://www.stats.bris.ac.uk/R/"))' && \
+    git clone https://github.com/Nik-Zainal-Group/signature.tools.lib.git /opt/opencga/signature.tools.lib && \
+    cd /opt/opencga/signature.tools.lib && \
+    git fetch origin --tags && \
     git checkout tags/v2.4.4 && \
     sed -i '/Mmusculus/d' DESCRIPTION && \
     sed -i '/Cfamiliaris/d' DESCRIPTION && \
     sed -i '/1000genomes/d' DESCRIPTION && \
     R -e 'options(timeout = 3600);devtools::install(repos="https://www.stats.bris.ac.uk/R/")' && \
-    ## Clean up
-    rm -rf /var/lib/apt/lists/* /tmp/* /opt/opencga/signature.tools.lib/.git && \
+    cd .. && \
+
+    ## 5. Clean up
+    rm -rf samtools-1.21 bcftools-1.21 /var/lib/apt/lists/* /tmp/* /opt/opencga/signature.tools.lib/.git && \
     strip --remove-section=.note.ABI-tag /usr/lib/x86_64-linux-gnu/libQt5Core.so.5
 
+# WORKDIR /opt/opencga/signature.tools.lib
+
+# RUN git fetch origin --tags && \
+#     git checkout tags/v2.4.4 && \
+#     sed -i '/Mmusculus/d' DESCRIPTION && \
+#     sed -i '/Cfamiliaris/d' DESCRIPTION && \
+#     sed -i '/1000genomes/d' DESCRIPTION && \
+#     R -e 'options(timeout = 3600);devtools::install(repos="https://www.stats.bris.ac.uk/R/")' && \
+#     ## Clean up
+#     rm -rf /var/lib/apt/lists/* /tmp/* /opt/opencga/signature.tools.lib/.git && \
+#     strip --remove-section=.note.ABI-tag /usr/lib/x86_64-linux-gnu/libQt5Core.so.5
+
+ENV BCFTOOLS_PLUGINS="/usr/local/bin"
+
 WORKDIR /opt/opencga
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
index 1393604cf5b..615edc45f3d 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
@@ -29,7 +29,7 @@ public abstract class OpenCgaCompleter implements Completer {
             .map(Candidate::new)
             .collect(toList());
 
-    private List<Candidate> variantList = asList( "aggregationstats","annotation-metadata","annotation-query","circos-run","cohort-stats-delete","cohort-stats-info","cohort-stats-run","exomiser-run","export-run","family-genotypes","family-qc-run","file-delete","gatk-run","genome-plot-run","gwas-run","hr-detect-run","index-run","individual-qc-run","inferred-sex-run","knockout-gene-query","knockout-individual-query","knockout-run","mendelian-error-run","metadata","mutational-signature-query","mutational-signature-run","plink-run","query","relatedness-run","rvtests-run","sample-aggregation-stats","sample-eligibility-run","sample-qc-run","sample-query","sample-run","sample-stats-query","sample-stats-run","stats-export-run","stats-run")
+    private List<Candidate> variantList = asList( "aggregationstats","annotation-metadata","annotation-query","circos-run","cohort-stats-delete","cohort-stats-info","cohort-stats-run","exomiser-run","export-run","family-genotypes","family-qc-run","file-delete","gatk-run","genome-plot-run","gwas-run","hr-detect-run","index-run","individual-qc-run","inferred-sex-run","knockout-gene-query","knockout-individual-query","knockout-run","liftover-run","mendelian-error-run","metadata","mutational-signature-query","mutational-signature-run","plink-run","query","relatedness-run","rvtests-run","sample-aggregation-stats","sample-eligibility-run","sample-qc-run","sample-query","sample-run","sample-stats-query","sample-stats-run","stats-export-run","stats-run")
             .stream()
             .map(Candidate::new)
             .collect(toList());
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
index 7530fa78a32..1820071ded0 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
@@ -67,6 +67,7 @@ public OpencgaCliOptionsParser() {
         analysisVariantSubCommands.addCommand("knockout-gene-query", analysisVariantCommandOptions.queryKnockoutGeneCommandOptions);
         analysisVariantSubCommands.addCommand("knockout-individual-query", analysisVariantCommandOptions.queryKnockoutIndividualCommandOptions);
         analysisVariantSubCommands.addCommand("knockout-run", analysisVariantCommandOptions.runKnockoutCommandOptions);
+        analysisVariantSubCommands.addCommand("liftover-run", analysisVariantCommandOptions.runLiftoverCommandOptions);
         analysisVariantSubCommands.addCommand("mendelian-error-run", analysisVariantCommandOptions.runMendelianErrorCommandOptions);
         analysisVariantSubCommands.addCommand("metadata", analysisVariantCommandOptions.metadataCommandOptions);
         analysisVariantSubCommands.addCommand("mutational-signature-query", analysisVariantCommandOptions.queryMutationalSignatureCommandOptions);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/AnalysisVariantCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/AnalysisVariantCommandExecutor.java
index 3427a69163c..793bad879fd 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/AnalysisVariantCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/AnalysisVariantCommandExecutor.java
@@ -41,6 +41,7 @@
 import org.opencb.opencga.core.models.variant.IndividualQcAnalysisParams;
 import org.opencb.opencga.core.models.variant.InferredSexAnalysisParams;
 import org.opencb.opencga.core.models.variant.KnockoutAnalysisParams;
+import org.opencb.opencga.core.models.variant.LiftoverWrapperParams;
 import org.opencb.opencga.core.models.variant.MendelianErrorAnalysisParams;
 import org.opencb.opencga.core.models.variant.MutationalSignatureAnalysisParams;
 import org.opencb.opencga.core.models.variant.PlinkWrapperParams;
@@ -156,6 +157,9 @@ public void execute() throws Exception {
             case "knockout-run":
                 queryResponse = runKnockout();
                 break;
+            case "liftover-run":
+                queryResponse = runLiftover();
+                break;
             case "mendelian-error-run":
                 queryResponse = runMendelianError();
                 break;
@@ -1072,6 +1076,47 @@ private RestResponse<Job> runKnockout() throws Exception {
         return openCGAClient.getVariantClient().runKnockout(knockoutAnalysisParams, queryParams);
     }
 
+    private RestResponse<Job> runLiftover() throws Exception {
+        logger.debug("Executing runLiftover in Analysis - Variant command line");
+
+        AnalysisVariantCommandOptions.RunLiftoverCommandOptions commandOptions = analysisVariantCommandOptions.runLiftoverCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("jobId", commandOptions.jobId);
+        queryParams.putIfNotEmpty("jobDescription", commandOptions.jobDescription);
+        queryParams.putIfNotEmpty("jobDependsOn", commandOptions.jobDependsOn);
+        queryParams.putIfNotEmpty("jobTags", commandOptions.jobTags);
+        queryParams.putIfNotEmpty("jobScheduledStartTime", commandOptions.jobScheduledStartTime);
+        queryParams.putIfNotEmpty("jobPriority", commandOptions.jobPriority);
+        queryParams.putIfNotNull("jobDryRun", commandOptions.jobDryRun);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        LiftoverWrapperParams liftoverWrapperParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<Job> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/analysis/variant/liftover/run"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            liftoverWrapperParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), LiftoverWrapperParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotEmpty(beanParams, "file",commandOptions.file, true);
+            putNestedIfNotEmpty(beanParams, "targetAssembly",commandOptions.targetAssembly, true);
+            putNestedIfNotEmpty(beanParams, "outdir",commandOptions.outdir, true);
+
+            liftoverWrapperParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), LiftoverWrapperParams.class);
+        }
+        return openCGAClient.getVariantClient().runLiftover(liftoverWrapperParams, queryParams);
+    }
+
     private RestResponse<Job> runMendelianError() throws Exception {
         logger.debug("Executing runMendelianError in Analysis - Variant command line");
 
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/AnalysisVariantCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/AnalysisVariantCommandOptions.java
index 1c83e822d82..eff2983e0a7 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/AnalysisVariantCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/AnalysisVariantCommandOptions.java
@@ -55,6 +55,7 @@ public class AnalysisVariantCommandOptions {
         public QueryKnockoutGeneCommandOptions queryKnockoutGeneCommandOptions;
         public QueryKnockoutIndividualCommandOptions queryKnockoutIndividualCommandOptions;
         public RunKnockoutCommandOptions runKnockoutCommandOptions;
+        public RunLiftoverCommandOptions runLiftoverCommandOptions;
         public RunMendelianErrorCommandOptions runMendelianErrorCommandOptions;
         public MetadataCommandOptions metadataCommandOptions;
         public QueryMutationalSignatureCommandOptions queryMutationalSignatureCommandOptions;
@@ -100,6 +101,7 @@ public AnalysisVariantCommandOptions(CommonCommandOptions commonCommandOptions,
         this.queryKnockoutGeneCommandOptions = new QueryKnockoutGeneCommandOptions();
         this.queryKnockoutIndividualCommandOptions = new QueryKnockoutIndividualCommandOptions();
         this.runKnockoutCommandOptions = new RunKnockoutCommandOptions();
+        this.runLiftoverCommandOptions = new RunLiftoverCommandOptions();
         this.runMendelianErrorCommandOptions = new RunMendelianErrorCommandOptions();
         this.metadataCommandOptions = new MetadataCommandOptions();
         this.queryMutationalSignatureCommandOptions = new QueryMutationalSignatureCommandOptions();
@@ -1445,6 +1447,53 @@ public class RunKnockoutCommandOptions {
     
     }
 
+    @Parameters(commandNames = {"liftover-run"}, commandDescription ="BCFtools liftover plugin maps coordinates from assembly 37 to 38.")
+    public class RunLiftoverCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--study", "-s"}, description = "study", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--job-id"}, description = "Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.", required = false, arity = 1)
+        public String jobId; 
+    
+        @Parameter(names = {"--job-description"}, description = "Job description", required = false, arity = 1)
+        public String jobDescription; 
+    
+        @Parameter(names = {"--job-depends-on"}, description = "Comma separated list of existing job IDs the job will depend on.", required = false, arity = 1)
+        public String jobDependsOn; 
+    
+        @Parameter(names = {"--job-tags"}, description = "Job tags", required = false, arity = 1)
+        public String jobTags; 
+    
+        @Parameter(names = {"--job-scheduled-start-time"}, description = "Time when the job is scheduled to start.", required = false, arity = 1)
+        public String jobScheduledStartTime; 
+    
+        @Parameter(names = {"--job-priority"}, description = "Priority of the job", required = false, arity = 1)
+        public String jobPriority; 
+    
+        @Parameter(names = {"--job-dry-run"}, description = "Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.", required = false, arity = 1)
+        public Boolean jobDryRun; 
+    
+        @Parameter(names = {"--file"}, description = "The body web service file parameter", required = false, arity = 1)
+        public String file;
+    
+        @Parameter(names = {"--target-assembly"}, description = "The body web service targetAssembly parameter", required = false, arity = 1)
+        public String targetAssembly;
+    
+        @Parameter(names = {"--outdir"}, description = "The body web service outdir parameter", required = false, arity = 1)
+        public String outdir;
+    
+    }
+
     @Parameters(commandNames = {"mendelian-error-run"}, commandDescription ="Run mendelian error analysis to infer uniparental disomy regions.")
     public class RunMendelianErrorCommandOptions {
     
diff --git a/opencga-client/src/main/R/R/Variant-methods.R b/opencga-client/src/main/R/R/Variant-methods.R
index 5413a7604b5..5ef54019f83 100644
--- a/opencga-client/src/main/R/R/Variant-methods.R
+++ b/opencga-client/src/main/R/R/Variant-methods.R
@@ -41,6 +41,7 @@
 #' | queryKnockoutGene | /{apiVersion}/analysis/variant/knockout/gene/query | limit, skip, study, job |
 #' | queryKnockoutIndividual | /{apiVersion}/analysis/variant/knockout/individual/query | limit, skip, study, job |
 #' | runKnockout | /{apiVersion}/analysis/variant/knockout/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
+#' | runLiftover | /{apiVersion}/analysis/variant/liftover/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | runMendelianError | /{apiVersion}/analysis/variant/mendelianError/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | metadata | /{apiVersion}/analysis/variant/metadata | project, study, file, sample, includeStudy, includeFile, includeSample, include, exclude |
 #' | queryMutationalSignature | /{apiVersion}/analysis/variant/mutationalSignature/query | study, sample, type, ct, biotype, fileData, filter, qual, region, gene, panel, panelModeOfInheritance, panelConfidence, panelFeatureType, panelRoleInCancer, panelIntersection, msId, msDescription |
@@ -378,6 +379,20 @@ setMethod("variantClient", "OpencgaR", function(OpencgaR, endpointName, params=N
         runKnockout=fetchOpenCGA(object=OpencgaR, category="analysis", categoryId=NULL, subcategory="variant/knockout",
                 subcategoryId=NULL, action="run", params=params, httpMethod="POST", as.queryParam=NULL, ...),
 
+        #' @section Endpoint /{apiVersion}/analysis/variant/liftover/run:
+        #' BCFtools liftover plugin maps coordinates from assembly 37 to 38.
+        #' @param study study.
+        #' @param jobId Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+        #' @param jobDescription Job description.
+        #' @param jobDependsOn Comma separated list of existing job IDs the job will depend on.
+        #' @param jobTags Job tags.
+        #' @param jobScheduledStartTime Time when the job is scheduled to start.
+        #' @param jobPriority Priority of the job.
+        #' @param jobDryRun Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+        #' @param data BCFtools +liftover plugin params.
+        runLiftover=fetchOpenCGA(object=OpencgaR, category="analysis", categoryId=NULL, subcategory="variant/liftover",
+                subcategoryId=NULL, action="run", params=params, httpMethod="POST", as.queryParam=NULL, ...),
+
         #' @section Endpoint /{apiVersion}/analysis/variant/mendelianError/run:
         #' Run mendelian error analysis to infer uniparental disomy regions.
         #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/VariantClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/VariantClient.java
index 6a68ae8ea82..00497e59d4c 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/VariantClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/VariantClient.java
@@ -44,6 +44,7 @@
 import org.opencb.opencga.core.models.variant.IndividualQcAnalysisParams;
 import org.opencb.opencga.core.models.variant.InferredSexAnalysisParams;
 import org.opencb.opencga.core.models.variant.KnockoutAnalysisParams;
+import org.opencb.opencga.core.models.variant.LiftoverWrapperParams;
 import org.opencb.opencga.core.models.variant.MendelianErrorAnalysisParams;
 import org.opencb.opencga.core.models.variant.MutationalSignatureAnalysisParams;
 import org.opencb.opencga.core.models.variant.PlinkWrapperParams;
@@ -549,6 +550,28 @@ public RestResponse<Job> runKnockout(KnockoutAnalysisParams data, ObjectMap para
         return execute("analysis", null, "variant/knockout", null, "run", params, POST, Job.class);
     }
 
+    /**
+     * BCFtools liftover plugin maps coordinates from assembly 37 to 38.
+     * @param data BCFtools +liftover plugin params.
+     * @param params Map containing any of the following optional parameters.
+     *       study: study.
+     *       jobId: Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.
+     *       jobDescription: Job description.
+     *       jobDependsOn: Comma separated list of existing job IDs the job will depend on.
+     *       jobTags: Job tags.
+     *       jobScheduledStartTime: Time when the job is scheduled to start.
+     *       jobPriority: Priority of the job.
+     *       jobDryRun: Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all
+     *            parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Job> runLiftover(LiftoverWrapperParams data, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.put("body", data);
+        return execute("analysis", null, "variant/liftover", null, "run", params, POST, Job.class);
+    }
+
     /**
      * Run mendelian error analysis to infer uniparental disomy regions.
      * @param data Mendelian error analysis params.
diff --git a/opencga-client/src/main/javascript/Variant.js b/opencga-client/src/main/javascript/Variant.js
index 7d8b01966da..4071bb5b276 100644
--- a/opencga-client/src/main/javascript/Variant.js
+++ b/opencga-client/src/main/javascript/Variant.js
@@ -444,6 +444,25 @@ export default class Variant extends OpenCGAParentClass {
         return this._post("analysis", null, "variant/knockout", null, "run", data, params);
     }
 
+    /** BCFtools liftover plugin maps coordinates from assembly 37 to 38.
+    * @param {Object} data - BCFtools +liftover plugin params.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - study.
+    * @param {String} [params.jobId] - Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not
+    *     provided.
+    * @param {String} [params.jobDescription] - Job description.
+    * @param {String} [params.jobDependsOn] - Comma separated list of existing job IDs the job will depend on.
+    * @param {String} [params.jobTags] - Job tags.
+    * @param {String} [params.jobScheduledStartTime] - Time when the job is scheduled to start.
+    * @param {String} [params.jobPriority] - Priority of the job.
+    * @param {Boolean} [params.jobDryRun] - Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will
+    *     validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    runLiftover(data, params) {
+        return this._post("analysis", null, "variant/liftover", null, "run", data, params);
+    }
+
     /** Run mendelian error analysis to infer uniparental disomy regions.
     * @param {Object} data - Mendelian error analysis params.
     * @param {Object} [params] - The Object containing the following optional parameters:
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/variant_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/variant_client.py
index 3993f48ba22..891e03972d6 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/variant_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/variant_client.py
@@ -570,6 +570,30 @@ def run_knockout(self, data=None, **options):
 
         return self._post(category='analysis', resource='run', subcategory='variant/knockout', data=data, **options)
 
+    def run_liftover(self, data=None, **options):
+        """
+        BCFtools liftover plugin maps coordinates from assembly 37 to 38.
+        PATH: /{apiVersion}/analysis/variant/liftover/run
+
+        :param dict data: BCFtools +liftover plugin params. (REQUIRED)
+        :param str study: study.
+        :param str job_id: Job ID. It must be a unique string within the
+            study. An ID will be autogenerated automatically if not provided.
+        :param str job_description: Job description.
+        :param str job_depends_on: Comma separated list of existing job IDs
+            the job will depend on.
+        :param str job_tags: Job tags.
+        :param str job_scheduled_start_time: Time when the job is scheduled to
+            start.
+        :param str job_priority: Priority of the job.
+        :param bool job_dry_run: Flag indicating that the job will be executed
+            in dry-run mode. In this mode, OpenCGA will validate that all
+            parameters and prerequisites are correctly set for successful
+            execution, but the job will not actually run.
+        """
+
+        return self._post(category='analysis', resource='run', subcategory='variant/liftover', data=data, **options)
+
     def run_mendelian_error(self, data=None, **options):
         """
         Run mendelian error analysis to infer uniparental disomy regions.
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/variant/LiftoverWrapperParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/variant/LiftoverWrapperParams.java
new file mode 100644
index 00000000000..f8ea4391ced
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/variant/LiftoverWrapperParams.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2015-2020 OpenCB
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.opencb.opencga.core.models.variant;
+
+import org.opencb.opencga.core.tools.ToolParams;
+
+public class LiftoverWrapperParams extends ToolParams {
+
+    public static final String DESCRIPTION = "BCFtools +liftover plugin params";
+
+    private String file;
+    private String targetAssembly;
+    private String outdir;
+
+    public LiftoverWrapperParams() {
+    }
+
+    public LiftoverWrapperParams(String file, String targetAssembly, String outdir) {
+        this.file = file;
+        this.targetAssembly = targetAssembly;
+        this.outdir = outdir;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("LiftoverWrapperParams{");
+        sb.append("file='").append(file).append('\'');
+        sb.append(", targetAssembly='").append(targetAssembly).append('\'');
+        sb.append(", outdir='").append(outdir).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getFile() {
+        return file;
+    }
+
+    public LiftoverWrapperParams setFile(String file) {
+        this.file = file;
+        return this;
+    }
+
+    public String getTargetAssembly() {
+        return targetAssembly;
+    }
+
+    public LiftoverWrapperParams setTargetAssembly(String targetAssembly) {
+        this.targetAssembly = targetAssembly;
+        return this;
+    }
+
+    public String getOutdir() {
+        return outdir;
+    }
+
+    public LiftoverWrapperParams setOutdir(String outdir) {
+        this.outdir = outdir;
+        return this;
+    }
+}
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/VariantWebService.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/VariantWebService.java
index be6ec91c91f..99e14ea8687 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/VariantWebService.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/VariantWebService.java
@@ -53,6 +53,7 @@
 import org.opencb.opencga.analysis.variant.stats.VariantStatsAnalysis;
 import org.opencb.opencga.analysis.wrappers.exomiser.ExomiserWrapperAnalysis;
 import org.opencb.opencga.analysis.wrappers.gatk.GatkWrapperAnalysis;
+import org.opencb.opencga.analysis.wrappers.liftover.LiftoverWrapperAnalysis;
 import org.opencb.opencga.analysis.wrappers.plink.PlinkWrapperAnalysis;
 import org.opencb.opencga.analysis.wrappers.rvtests.RvtestsWrapperAnalysis;
 import org.opencb.opencga.catalog.exceptions.CatalogException;
@@ -1196,6 +1197,22 @@ public Response sampleQcRun(
         return submitJob(SampleQcAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
+    @POST
+    @Path("/liftover/run")
+    @ApiOperation(value = LiftoverWrapperAnalysis.DESCRIPTION, response = Job.class)
+    public Response liftoverRun(
+            @ApiParam(value = ParamConstants.STUDY_PARAM) @QueryParam(ParamConstants.STUDY_PARAM) String study,
+            @ApiParam(value = ParamConstants.JOB_ID_CREATION_DESCRIPTION) @QueryParam(ParamConstants.JOB_ID) String jobName,
+            @ApiParam(value = ParamConstants.JOB_DESCRIPTION_DESCRIPTION) @QueryParam(ParamConstants.JOB_DESCRIPTION) String jobDescription,
+            @ApiParam(value = ParamConstants.JOB_DEPENDS_ON_DESCRIPTION) @QueryParam(JOB_DEPENDS_ON) String dependsOn,
+            @ApiParam(value = ParamConstants.JOB_TAGS_DESCRIPTION) @QueryParam(ParamConstants.JOB_TAGS) String jobTags,
+            @ApiParam(value = ParamConstants.JOB_SCHEDULED_START_TIME_DESCRIPTION) @QueryParam(ParamConstants.JOB_SCHEDULED_START_TIME) String scheduledStartTime,
+            @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
+            @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
+            @ApiParam(value = LiftoverWrapperParams.DESCRIPTION, required = true) LiftoverWrapperParams params) {
+        return submitJob(LiftoverWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+    }
+
     @POST
     @Path("/plink/run")
     @ApiOperation(value = PlinkWrapperAnalysis.DESCRIPTION, response = Job.class)

From 246dfab1c59a0ebbae3a82c776534f624115c931 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 10:06:34 +0200
Subject: [PATCH 72/99] core: add new WorkflowVariable, #TASK-6445

---
 .../core/models/workflow/Workflow.java        |   9 +-
 .../models/workflow/WorkflowCreateParams.java |   9 +-
 .../models/workflow/WorkflowUpdateParams.java |  13 +--
 .../models/workflow/WorkflowVariable.java     | 110 ++++++++++++++++++
 4 files changed, 124 insertions(+), 17 deletions(-)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowVariable.java

diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index 1d3768fa49a..4728c6ad395 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -4,7 +4,6 @@
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
 import org.opencb.opencga.core.models.PrivateStudyUid;
-import org.opencb.opencga.core.models.study.Variable;
 
 import java.util.List;
 import java.util.Map;
@@ -36,7 +35,7 @@ public class Workflow extends PrivateStudyUid {
     private List<String> tags;
 
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
-    private List<Variable> variables;
+    private List<WorkflowVariable> variables;
 
     @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
     private WorkflowMinimumRequirements minimumRequirements;
@@ -79,7 +78,7 @@ public Workflow() {
     }
 
     public Workflow(String id, String name, String description, Type type, WorkflowSystem manager, List<String> tags,
-                    List<Variable> variables, WorkflowMinimumRequirements minimumRequirements, boolean draft,
+                    List<WorkflowVariable> variables, WorkflowMinimumRequirements minimumRequirements, boolean draft,
                     WorkflowRepository repository, List<WorkflowScript> scripts, WorkflowInternal internal, String creationDate,
                     String modificationDate, Map<String, Object> attributes) {
         this.id = id;
@@ -239,11 +238,11 @@ public Workflow setTags(List<String> tags) {
         return this;
     }
 
-    public List<Variable> getVariables() {
+    public List<WorkflowVariable> getVariables() {
         return variables;
     }
 
-    public Workflow setVariables(List<Variable> variables) {
+    public Workflow setVariables(List<WorkflowVariable> variables) {
         this.variables = variables;
         return this;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
index 3241be4c896..a0cde6d36e8 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -2,7 +2,6 @@
 
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
-import org.opencb.opencga.core.models.study.Variable;
 
 import java.util.List;
 import java.util.Map;
@@ -35,7 +34,7 @@ public class WorkflowCreateParams {
     private WorkflowRepository repository;
 
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
-    private List<Variable> variables;
+    private List<WorkflowVariable> variables;
 
     @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
     private WorkflowMinimumRequirements minimumRequirements;
@@ -56,7 +55,7 @@ public WorkflowCreateParams() {
     }
 
     public WorkflowCreateParams(String id, String name, String description, WorkflowSystem manager, Workflow.Type type, List<String> tags,
-                                boolean draft, WorkflowRepository repository, List<Variable> variables,
+                                boolean draft, WorkflowRepository repository, List<WorkflowVariable> variables,
                                 WorkflowMinimumRequirements minimumRequirements, List<WorkflowScript> scripts, String creationDate,
                                 String modificationDate, Map<String, Object> attributes) {
         this.id = id;
@@ -173,11 +172,11 @@ public WorkflowCreateParams setRepository(WorkflowRepository repository) {
         return this;
     }
 
-    public List<Variable> getVariables() {
+    public List<WorkflowVariable> getVariables() {
         return variables;
     }
 
-    public WorkflowCreateParams setVariables(List<Variable> variables) {
+    public WorkflowCreateParams setVariables(List<WorkflowVariable> variables) {
         this.variables = variables;
         return this;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
index fdcdb0697df..ccd88bcb29e 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
@@ -2,7 +2,6 @@
 
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
-import org.opencb.opencga.core.models.study.Variable;
 
 import java.util.List;
 import java.util.Map;
@@ -34,7 +33,7 @@ public class WorkflowUpdateParams {
     private List<WorkflowScript> scripts;
 
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
-    private List<Variable> variables;
+    private List<WorkflowVariable> variables;
 
     @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
     private WorkflowMinimumRequirements minimumRequirements;
@@ -52,9 +51,9 @@ public WorkflowUpdateParams() {
     }
 
     public WorkflowUpdateParams(String name, String description, WorkflowSystem manager, Workflow.Type type, List<String> tags,
-                                boolean draft, WorkflowRepository repository, List<WorkflowScript> scripts, List<Variable> variables,
-                                WorkflowMinimumRequirements minimumRequirements, String creationDate, String modificationDate,
-                                Map<String, Object> attributes) {
+                                boolean draft, WorkflowRepository repository, List<WorkflowScript> scripts,
+                                List<WorkflowVariable> variables, WorkflowMinimumRequirements minimumRequirements, String creationDate,
+                                String modificationDate, Map<String, Object> attributes) {
         this.name = name;
         this.description = description;
         this.manager = manager;
@@ -162,11 +161,11 @@ public WorkflowUpdateParams setScripts(List<WorkflowScript> scripts) {
         return this;
     }
 
-    public List<Variable> getVariables() {
+    public List<WorkflowVariable> getVariables() {
         return variables;
     }
 
-    public WorkflowUpdateParams setVariables(List<Variable> variables) {
+    public WorkflowUpdateParams setVariables(List<WorkflowVariable> variables) {
         this.variables = variables;
         return this;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowVariable.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowVariable.java
new file mode 100644
index 00000000000..27d03fc8d27
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowVariable.java
@@ -0,0 +1,110 @@
+package org.opencb.opencga.core.models.workflow;
+
+public class WorkflowVariable {
+
+    private String id;
+    private String name;
+    private String description;
+    private WorkflowType type;
+    private boolean required;
+    private String defaultValue;
+    private boolean output;
+
+    public enum WorkflowType {
+        INT,
+        STRING,
+        BOOLEAN,
+        FLAG
+    }
+
+    public WorkflowVariable() {
+    }
+
+    public WorkflowVariable(String id, String name, String description, WorkflowType type, boolean required, String defaultValue,
+                            boolean output) {
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.type = type;
+        this.required = required;
+        this.defaultValue = defaultValue;
+        this.output = output;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowVariable{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", name='").append(name).append('\'');
+        sb.append(", description='").append(description).append('\'');
+        sb.append(", type=").append(type);
+        sb.append(", required=").append(required);
+        sb.append(", defaultValue='").append(defaultValue).append('\'');
+        sb.append(", output=").append(output);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public WorkflowVariable setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public WorkflowVariable setName(String name) {
+        this.name = name;
+        return this;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public WorkflowVariable setDescription(String description) {
+        this.description = description;
+        return this;
+    }
+
+    public WorkflowType getType() {
+        return type;
+    }
+
+    public WorkflowVariable setType(WorkflowType type) {
+        this.type = type;
+        return this;
+    }
+
+    public boolean isRequired() {
+        return required;
+    }
+
+    public WorkflowVariable setRequired(boolean required) {
+        this.required = required;
+        return this;
+    }
+
+    public String getDefaultValue() {
+        return defaultValue;
+    }
+
+    public WorkflowVariable setDefaultValue(String defaultValue) {
+        this.defaultValue = defaultValue;
+        return this;
+    }
+
+    public boolean isOutput() {
+        return output;
+    }
+
+    public WorkflowVariable setOutput(boolean output) {
+        this.output = output;
+        return this;
+    }
+}

From 97c020698cfeb88d3027818b4f5f2e4d11e74fe0 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 10:10:19 +0200
Subject: [PATCH 73/99] analysis: use new opencb workflow repository,
 #TASK-6445

---
 .../opencb/opencga/analysis/workflow/NextFlowExecutor.java    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 40d0dc26bc1..b190c1b3026 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -190,9 +190,9 @@ protected void run() throws Exception {
         AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(outDirPath, outDirPath);
 
 //        String dockerImage = "nextflow/nextflow:" + workflow.getManager().getVersion();
-        String dockerImage = "pfurio/nextflow";
+        String dockerImage = "opencb/opencga-workflow";
         StringBuilder stringBuilder = new StringBuilder()
-                .append("bash -c \"nextflow -c ").append(nextflowConfigPath).append(" run ");
+                .append("bash -c \"NXF_VER=").append(workflow.getManager().getVersion()).append(" nextflow -c ").append(nextflowConfigPath).append(" run ");
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());

From c15799b3ffbfe93426862311731d3e95aa044efb Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 10:11:15 +0200
Subject: [PATCH 74/99] analysis: uncomment job update, #TASK-6445

---
 .../opencb/opencga/analysis/workflow/NextFlowExecutor.java | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index b190c1b3026..2aaced03589 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -107,7 +107,7 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
-//        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
+        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
 
         this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
@@ -189,7 +189,6 @@ protected void run() throws Exception {
         // Build output binding
         AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(outDirPath, outDirPath);
 
-//        String dockerImage = "nextflow/nextflow:" + workflow.getManager().getVersion();
         String dockerImage = "opencb/opencga-workflow";
         StringBuilder stringBuilder = new StringBuilder()
                 .append("bash -c \"NXF_VER=").append(workflow.getManager().getVersion()).append(" nextflow -c ").append(nextflowConfigPath).append(" run ");
@@ -211,10 +210,6 @@ protected void run() throws Exception {
             stringBuilder.append(" ").append(cliParams);
         }
         stringBuilder.append(" -with-report ").append(outDirPath).append("/report.html\"");
-//        // And give ownership permissions to the user running this process
-//        stringBuilder.append("; chown -R ")
-//                .append(UserProcessUtils.getUserUid()).append(":").append(UserProcessUtils.getGroupId()).append(" ").append(outputDir)
-//                .append("\"");
 
         startTraceFileMonitor();
 

From d74a5553701f42217443264c59018193e658fd02 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 11:48:38 +0200
Subject: [PATCH 75/99] analysis: improve nextflow executor, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   | 146 ++++++++++++++----
 .../opencga/catalog/utils/InputFileUtils.java |  10 ++
 2 files changed, 122 insertions(+), 34 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 2aaced03589..d433d999ca5 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -12,6 +12,7 @@
 import org.opencb.commons.utils.DockerUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
 import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
+import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.utils.InputFileUtils;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
@@ -22,6 +23,7 @@
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.models.workflow.WorkflowScript;
+import org.opencb.opencga.core.models.workflow.WorkflowVariable;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
@@ -50,8 +52,7 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
 
     private Workflow workflow;
     private String cliParams;
-    // Build list of inputfiles in case we need to specifically mount them in read only mode
-    private List<String> inputFileUris;
+
     // Build list of inputfiles in case we need to specifically mount them in read only mode
     List<AbstractMap.SimpleEntry<String, String>> inputBindings;
 
@@ -62,9 +63,6 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
     private Thread thread;
     private final int monitorThreadPeriod = 5000;
 
-//    private final Path inputDir = Paths.get("/data/input");
-//    private final String outputDir = "/data/output";
-
     private final static Logger logger = LoggerFactory.getLogger(NextFlowExecutor.class);
 
     @Override
@@ -97,6 +95,18 @@ protected void check() throws Exception {
 
         outDirPath = getOutDir().toAbsolutePath().toString();
 
+        Set<String> mandatoryParams = new HashSet<>();
+        Map<String, WorkflowVariable> variableMap = new HashMap<>();
+        if (CollectionUtils.isNotEmpty(workflow.getVariables())) {
+            for (WorkflowVariable variable : workflow.getVariables()) {
+                String variableId = removePrefix(variable.getId());
+                variableMap.put(variableId, variable);
+                if (variable.isRequired()) {
+                    mandatoryParams.add(variableId);
+                }
+            }
+        }
+
         // Update job tags and attributes
         ToolInfoExecutor toolInfoExecutor = new ToolInfoExecutor(workflow.getManager().getId().name(), workflow.getManager().getVersion());
         Set<String> tags = new HashSet<>();
@@ -111,55 +121,123 @@ protected void check() throws Exception {
 
         this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
-            this.inputFileUris = new LinkedList<>();
             InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
 
             StringBuilder cliParamsBuilder = new StringBuilder();
             for (Map.Entry<String, String> entry : nextflowParams.getParams().entrySet()) {
+                String variableId = removePrefix(entry.getKey());
+                // Remove from the mandatoryParams set
+                mandatoryParams.remove(variableId);
+
+                WorkflowVariable workflowVariable = variableMap.get(variableId);
+
                 if (entry.getKey().startsWith("-")) {
                     cliParamsBuilder.append(entry.getKey()).append(" ");
                 } else {
                     cliParamsBuilder.append("--").append(entry.getKey()).append(" ");
                 }
                 if (StringUtils.isNotEmpty(entry.getValue())) {
-                    if (inputFileUtils.isValidOpenCGAFile(entry.getValue())) {
-                        File file = inputFileUtils.findOpenCGAFileFromPattern(study, entry.getValue(), token);
-                        if (inputFileUtils.fileMayContainReferencesToOtherFiles(file)) {
-                            Path outputFile = temporalInputDir.resolve(file.getName());
-                            List<File> files = inputFileUtils.findAndReplaceFilePathToUrisFromFile(study, file, outputFile, token);
-
-                            // Write outputFile as inputBinding
-                            inputBindings.add(new AbstractMap.SimpleEntry<>(outputFile.toString(), outputFile.toString()));
-                            logger.info("Params: OpenCGA input file: {}", outputFile);
-                            cliParamsBuilder.append(outputFile).append(" ");
-
-                            // Add files to inputBindings to ensure they are also mounted (if any)
-                            for (File tmpFile : files) {
-                                inputBindings.add(new AbstractMap.SimpleEntry<>(tmpFile.getUri().getPath(), tmpFile.getUri().getPath()));
-                                logger.info("Inner files from '{}': OpenCGA input file: '{}'", outputFile, tmpFile.getUri().getPath());
-                            }
-                        } else {
-                            String path = file.getUri().getPath();
-                            inputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
-                            logger.info("Params: OpenCGA input file: {}", path);
-                            cliParamsBuilder.append(path).append(" ");
-                        }
-                    } else if (inputFileUtils.isDynamicOutputFolder(entry.getValue())) {
-                        String dynamicOutputFolder = inputFileUtils.getDynamicOutputFolder(entry.getValue(), outDirPath);
-                        logger.info("Params: Dynamic output folder: {}", dynamicOutputFolder);
-                        cliParamsBuilder.append(dynamicOutputFolder).append(" ");
+                    if ((workflowVariable != null && workflowVariable.isOutput()) || inputFileUtils.isDynamicOutputFolder(entry.getValue())) {
+                        processOutputCli(entry.getValue(), inputFileUtils, cliParamsBuilder);
                     } else {
-                        cliParamsBuilder.append(entry.getValue()).append(" ");
+                        processInputCli(entry.getValue(), inputFileUtils, cliParamsBuilder);
+                    }
+                } else if (workflowVariable != null) {
+                    if (StringUtils.isNotEmpty(workflowVariable.getDefaultValue())) {
+                        cliParamsBuilder.append(workflowVariable.getDefaultValue()).append(" ");
+                    } else if (workflowVariable.isOutput()) {
+                        processOutputCli("", inputFileUtils, cliParamsBuilder);
+                    } else if (workflowVariable.isRequired() && workflowVariable.getType() != WorkflowVariable.WorkflowType.FLAG) {
+                        throw new ToolException("Missing value for mandatory parameter: " + variableId);
                     }
                 }
             }
+            for (String mandatoryParam : mandatoryParams) {
+                logger.info("Processing missing mandatory param: '{}'", mandatoryParam);
+                WorkflowVariable workflowVariable = variableMap.get(mandatoryParam);
+
+                if (workflowVariable.getId().startsWith("-")) {
+                    cliParamsBuilder.append(workflowVariable.getId()).append(" ");
+                } else {
+                    cliParamsBuilder.append("--").append(workflowVariable.getId()).append(" ");
+                }
+
+                if (StringUtils.isNotEmpty(workflowVariable.getDefaultValue())) {
+                    if (workflowVariable.isOutput()) {
+                        processOutputCli(workflowVariable.getDefaultValue(), inputFileUtils, cliParamsBuilder);
+                    } else {
+                        processInputCli(workflowVariable.getDefaultValue(), inputFileUtils, cliParamsBuilder);
+                    }
+                } else if (workflowVariable.isOutput()) {
+                    processOutputCli("", inputFileUtils, cliParamsBuilder);
+                } else {
+                    throw new ToolException("Missing mandatory parameter: " + mandatoryParam);
+                }
+            }
+
             this.cliParams = cliParamsBuilder.toString();
         } else {
             this.cliParams = "";
-            this.inputFileUris = Collections.emptyList();
         }
     }
 
+    void processInputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) throws CatalogException {
+        if (inputFileUtils.isValidOpenCGAFile(value)) {
+            File file = inputFileUtils.findOpenCGAFileFromPattern(study, value, token);
+            if (inputFileUtils.fileMayContainReferencesToOtherFiles(file)) {
+                Path outputFile = temporalInputDir.resolve(file.getName());
+                List<File> files = inputFileUtils.findAndReplaceFilePathToUrisFromFile(study, file, outputFile, token);
+
+                // Write outputFile as inputBinding
+                inputBindings.add(new AbstractMap.SimpleEntry<>(outputFile.toString(), outputFile.toString()));
+                logger.info("Params: OpenCGA input file: {}", outputFile);
+                cliParamsBuilder.append(outputFile).append(" ");
+
+                // Add files to inputBindings to ensure they are also mounted (if any)
+                for (File tmpFile : files) {
+                    inputBindings.add(new AbstractMap.SimpleEntry<>(tmpFile.getUri().getPath(), tmpFile.getUri().getPath()));
+                    logger.info("Inner files from '{}': OpenCGA input file: '{}'", outputFile, tmpFile.getUri().getPath());
+                }
+            } else {
+                String path = file.getUri().getPath();
+                inputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
+                logger.info("Params: OpenCGA input file: {}", path);
+                cliParamsBuilder.append(path).append(" ");
+            }
+        } else {
+            cliParamsBuilder.append(value).append(" ");
+        }
+
+    }
+
+    void processOutputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) {
+        String dynamicOutputFolder;
+        if (inputFileUtils.isDynamicOutputFolder(value)) {
+            // If it starts with $OUTPUT/...
+            dynamicOutputFolder = inputFileUtils.getDynamicOutputFolder(value, outDirPath);
+        } else {
+            // If it starts directly with the subpath...
+            dynamicOutputFolder = inputFileUtils.appendSubpath(outDirPath, value);
+        }
+        logger.info("Params: Dynamic output folder: {}", dynamicOutputFolder);
+        cliParamsBuilder.append(dynamicOutputFolder).append(" ");
+    }
+
+    /**
+     * Given a variable name, it removes the prefix '-' if present.
+     * Example: --input -> input; -input -> input; input -> input
+     *
+     * @param variable A parameter of the nextflow command line.
+     * @return the variable removing any '-' prefix.
+     */
+    private String removePrefix(String variable) {
+        String value = variable;
+        while (value.startsWith("-")) {
+            value = value.substring(1);
+        }
+        return value;
+    }
+
     @Override
     protected void run() throws Exception {
         for (WorkflowScript script : workflow.getScripts()) {
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
index f19f20be8aa..25543c10f35 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
@@ -107,4 +107,14 @@ public String getDynamicOutputFolder(String file, String outDir) {
         return outDir + file.substring(OUTPUT.length());
     }
 
+    public String appendSubpath(String path, String subpath) {
+        if ((path.endsWith("/") && !subpath.startsWith("/")) || (!path.endsWith("/") && subpath.startsWith("/"))) {
+            return path + subpath;
+        } else if (path.endsWith("/") && subpath.startsWith("/")) {
+            return path + subpath.substring(1);
+        } else {
+            return path + "/" + subpath;
+        }
+    }
+
 }

From 14e6b6bf37aee69758b08c9403e1155f7174e388 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 13:14:16 +0200
Subject: [PATCH 76/99] analysis: change workflow docker, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   |  2 +-
 .../analysis/tools/WorkflowExecutorTest.java  | 21 ++++++++++++++++---
 2 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index d433d999ca5..160bddd3bbd 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -267,7 +267,7 @@ protected void run() throws Exception {
         // Build output binding
         AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(outDirPath, outDirPath);
 
-        String dockerImage = "opencb/opencga-workflow";
+        String dockerImage = "opencb/opencga-workflow:TASK-6445";
         StringBuilder stringBuilder = new StringBuilder()
                 .append("bash -c \"NXF_VER=").append(workflow.getManager().getVersion()).append(" nextflow -c ").append(nextflowConfigPath).append(" run ");
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index d26f1362434..7425dd5b722 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -21,6 +21,7 @@
 import java.io.InputStream;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
@@ -83,6 +84,20 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         WorkflowCreateParams workflow = new WorkflowCreateParams()
                 .setId("workflow")
                 .setType(Workflow.Type.OTHER)
+                .setVariables(Arrays.asList(
+                        new WorkflowVariable()
+                                .setId("outdir")
+                                .setOutput(true)
+                                .setRequired(true),
+                        new WorkflowVariable()
+                                .setId("genome")
+                                .setRequired(true)
+                                .setDefaultValue("GRCh37"),
+                        new WorkflowVariable()
+                                .setId("-profile")
+                                .setRequired(true)
+                                .setDefaultValue("docker")
+                ))
                 .setRepository(new WorkflowRepository("nf-core/demo"));
         catalogManager.getWorkflowManager().create(studyFqn, workflow.toWorkflow(), QueryOptions.empty(), ownerToken);
 
@@ -99,9 +114,9 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
         Map<String, String> cliParams = new HashMap<>();
         cliParams.put("input", "file://samplesheet.csv");
-        cliParams.put("outdir", "$OUTPUT");
-        cliParams.put("genome", "GRCh37");
-        cliParams.put("-profile", "docker");
+//        cliParams.put("outdir", "$OUTPUT");
+//        cliParams.put("genome", "GRCh37");
+//        cliParams.put("-profile", "docker");
         NextFlowRunParams runParams = new NextFlowRunParams(workflow.getId(), 1, cliParams);
         ObjectMap params = runParams.toObjectMap();
         params.put(ParamConstants.STUDY_PARAM, studyFqn);

From d6d45c04636b0d7d205046f6c8ab989b08c080a1 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 14:33:40 +0200
Subject: [PATCH 77/99] analysis: fix param processing in executor, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   | 46 +++++++++----------
 .../analysis/tools/WorkflowExecutorTest.java  |  3 ++
 2 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 160bddd3bbd..ed9524f94df 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -73,6 +73,8 @@ protected void check() throws Exception {
             throw new IllegalArgumentException("Missing Nextflow ID");
         }
 
+        InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
+
         dockerParams = new HashMap<>();
         temporalInputDir = Files.createDirectory(getOutDir().resolve(".opencga_input"));
 
@@ -119,11 +121,10 @@ protected void check() throws Exception {
         }
         updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
 
+        StringBuilder cliParamsBuilder = new StringBuilder();
         this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
-            InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
 
-            StringBuilder cliParamsBuilder = new StringBuilder();
             for (Map.Entry<String, String> entry : nextflowParams.getParams().entrySet()) {
                 String variableId = removePrefix(entry.getKey());
                 // Remove from the mandatoryParams set
@@ -152,33 +153,32 @@ protected void check() throws Exception {
                     }
                 }
             }
-            for (String mandatoryParam : mandatoryParams) {
-                logger.info("Processing missing mandatory param: '{}'", mandatoryParam);
-                WorkflowVariable workflowVariable = variableMap.get(mandatoryParam);
+        }
 
-                if (workflowVariable.getId().startsWith("-")) {
-                    cliParamsBuilder.append(workflowVariable.getId()).append(" ");
-                } else {
-                    cliParamsBuilder.append("--").append(workflowVariable.getId()).append(" ");
-                }
+        for (String mandatoryParam : mandatoryParams) {
+            logger.info("Processing missing mandatory param: '{}'", mandatoryParam);
+            WorkflowVariable workflowVariable = variableMap.get(mandatoryParam);
 
-                if (StringUtils.isNotEmpty(workflowVariable.getDefaultValue())) {
-                    if (workflowVariable.isOutput()) {
-                        processOutputCli(workflowVariable.getDefaultValue(), inputFileUtils, cliParamsBuilder);
-                    } else {
-                        processInputCli(workflowVariable.getDefaultValue(), inputFileUtils, cliParamsBuilder);
-                    }
-                } else if (workflowVariable.isOutput()) {
-                    processOutputCli("", inputFileUtils, cliParamsBuilder);
+            if (workflowVariable.getId().startsWith("-")) {
+                cliParamsBuilder.append(workflowVariable.getId()).append(" ");
+            } else {
+                cliParamsBuilder.append("--").append(workflowVariable.getId()).append(" ");
+            }
+
+            if (StringUtils.isNotEmpty(workflowVariable.getDefaultValue())) {
+                if (workflowVariable.isOutput()) {
+                    processOutputCli(workflowVariable.getDefaultValue(), inputFileUtils, cliParamsBuilder);
                 } else {
-                    throw new ToolException("Missing mandatory parameter: " + mandatoryParam);
+                    processInputCli(workflowVariable.getDefaultValue(), inputFileUtils, cliParamsBuilder);
                 }
+            } else if (workflowVariable.isOutput()) {
+                processOutputCli("", inputFileUtils, cliParamsBuilder);
+            } else {
+                throw new ToolException("Missing mandatory parameter: " + mandatoryParam);
             }
-
-            this.cliParams = cliParamsBuilder.toString();
-        } else {
-            this.cliParams = "";
         }
+
+        this.cliParams = cliParamsBuilder.toString();
     }
 
     void processInputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) throws CatalogException {
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index 7425dd5b722..abf85b4e2c9 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -85,6 +85,9 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
                 .setId("workflow")
                 .setType(Workflow.Type.OTHER)
                 .setVariables(Arrays.asList(
+                        new WorkflowVariable()
+                                .setId("input")
+                                .setRequired(true),
                         new WorkflowVariable()
                                 .setId("outdir")
                                 .setOutput(true)

From 2e91ab402e4f0c6768cc56196fc22ad953e4dea9 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 14:46:53 +0200
Subject: [PATCH 78/99] analysis: remove temporal files generated by nextflow,
 #TASK-6445

---
 .../opencga/analysis/workflow/NextFlowExecutor.java  | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index ed9524f94df..d1717460f66 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -304,6 +304,18 @@ protected void run() throws Exception {
                     .forEach(java.io.File::delete);
         }
 
+        // Delete temporal files and folders created by nextflow
+        try (Stream<Path> paths = Files.walk(getOutDir().resolve(".nextflow"))) {
+            paths.sorted(Comparator.reverseOrder())
+                    .map(Path::toFile)
+                    .forEach(java.io.File::delete);
+        }
+        try (Stream<Path> paths = Files.walk(getOutDir().resolve("work"))) {
+            paths.sorted(Comparator.reverseOrder())
+                    .map(Path::toFile)
+                    .forEach(java.io.File::delete);
+        }
+
     }
 
     @Override

From ab8086a35d4b93a99d126573fece51d9123064ce Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 15:50:31 +0200
Subject: [PATCH 79/99] analysis: improve last execution steps, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   | 26 ++++++++++++++-----
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index d1717460f66..2c431c104a0 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -32,6 +32,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.net.URL;
 import java.nio.file.Files;
@@ -295,35 +296,46 @@ protected void run() throws Exception {
         StopWatch stopWatch = StopWatch.createStarted();
         DockerUtils.run(dockerImage, inputBindings, outputBinding, stringBuilder.toString(), dockerParams);
         logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+    }
+
+    @Override
+    protected void onShutdown() {
         endTraceFileMonitor();
+        deleteTemporalFiles();
+    }
 
+    private void deleteTemporalFiles() {
         // Delete input files and temporal directory
         try (Stream<Path> paths = Files.walk(temporalInputDir)) {
             paths.sorted(Comparator.reverseOrder())
                     .map(Path::toFile)
                     .forEach(java.io.File::delete);
+        } catch (IOException e) {
+            logger.error("Could not delete temporal input directory: " + temporalInputDir, e);
         }
-
         // Delete temporal files and folders created by nextflow
         try (Stream<Path> paths = Files.walk(getOutDir().resolve(".nextflow"))) {
             paths.sorted(Comparator.reverseOrder())
                     .map(Path::toFile)
                     .forEach(java.io.File::delete);
+        } catch (IOException e) {
+            logger.error("Could not delete temporal nextflow directory: " + getOutDir().resolve(".nextflow"), e);
         }
         try (Stream<Path> paths = Files.walk(getOutDir().resolve("work"))) {
             paths.sorted(Comparator.reverseOrder())
                     .map(Path::toFile)
                     .forEach(java.io.File::delete);
+        } catch (IOException e) {
+            logger.error("Could not delete temporal work directory: " + getOutDir().resolve("work"), e);
         }
 
     }
 
-    @Override
-    protected void onShutdown() {
-        super.onShutdown();
-        endTraceFileMonitor();
-    }
-
     protected void endTraceFileMonitor() {
         if (thread != null) {
             thread.interrupt();

From be54d85b6cf5541b762568efa85ffaee079a15f6 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Mon, 30 Sep 2024 16:22:31 +0200
Subject: [PATCH 80/99] analysis: improve cleaning resources step, #TASK-6445

---
 .../opencga/analysis/tools/OpenCgaTool.java    |  7 +++++++
 .../analysis/workflow/NextFlowExecutor.java    | 18 +++++++++---------
 .../analysis/tools/WorkflowExecutorTest.java   |  2 +-
 3 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
index 75720aee064..16d610eacdb 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
@@ -278,6 +278,7 @@ public final ExecutionResult start() throws ToolException {
             logException(exception);
             privateLogger.info("------- Tool '" + getId() + "' executed in "
                     + TimeUtils.durationToString(result.getEnd().getTime() - result.getStart().getTime()) + " -------");
+            close();
         }
         return result;
     }
@@ -341,6 +342,12 @@ protected void check() throws Exception {
      */
     protected abstract void run() throws Exception;
 
+    /**
+     * Method that may be overrided by subclasses to clean up resources.
+     */
+    protected void close() {
+    }
+
     /**
      * Method to be called by the Runtime shutdownHook in case of an unexpected system shutdown.
      */
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 2c431c104a0..74723c16646 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -150,7 +150,7 @@ protected void check() throws Exception {
                     } else if (workflowVariable.isOutput()) {
                         processOutputCli("", inputFileUtils, cliParamsBuilder);
                     } else if (workflowVariable.isRequired() && workflowVariable.getType() != WorkflowVariable.WorkflowType.FLAG) {
-                        throw new ToolException("Missing value for mandatory parameter: " + variableId);
+                        throw new ToolException("Missing value for mandatory parameter: '" + variableId + "'.");
                     }
                 }
             }
@@ -175,7 +175,7 @@ protected void check() throws Exception {
             } else if (workflowVariable.isOutput()) {
                 processOutputCli("", inputFileUtils, cliParamsBuilder);
             } else {
-                throw new ToolException("Missing mandatory parameter: " + mandatoryParam);
+                throw new ToolException("Missing mandatory parameter: '" + mandatoryParam + "'.");
             }
         }
 
@@ -191,7 +191,7 @@ void processInputCli(String value, InputFileUtils inputFileUtils, StringBuilder
 
                 // Write outputFile as inputBinding
                 inputBindings.add(new AbstractMap.SimpleEntry<>(outputFile.toString(), outputFile.toString()));
-                logger.info("Params: OpenCGA input file: {}", outputFile);
+                logger.info("Params: OpenCGA input file: '{}'", outputFile);
                 cliParamsBuilder.append(outputFile).append(" ");
 
                 // Add files to inputBindings to ensure they are also mounted (if any)
@@ -202,7 +202,7 @@ void processInputCli(String value, InputFileUtils inputFileUtils, StringBuilder
             } else {
                 String path = file.getUri().getPath();
                 inputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
-                logger.info("Params: OpenCGA input file: {}", path);
+                logger.info("Params: OpenCGA input file: '{}'", path);
                 cliParamsBuilder.append(path).append(" ");
             }
         } else {
@@ -220,7 +220,7 @@ void processOutputCli(String value, InputFileUtils inputFileUtils, StringBuilder
             // If it starts directly with the subpath...
             dynamicOutputFolder = inputFileUtils.appendSubpath(outDirPath, value);
         }
-        logger.info("Params: Dynamic output folder: {}", dynamicOutputFolder);
+        logger.info("Params: Dynamic output folder: '{}'", dynamicOutputFolder);
         cliParamsBuilder.append(dynamicOutputFolder).append(" ");
     }
 
@@ -304,7 +304,7 @@ protected void finalize() throws Throwable {
     }
 
     @Override
-    protected void onShutdown() {
+    protected void close() {
         endTraceFileMonitor();
         deleteTemporalFiles();
     }
@@ -316,7 +316,7 @@ private void deleteTemporalFiles() {
                     .map(Path::toFile)
                     .forEach(java.io.File::delete);
         } catch (IOException e) {
-            logger.error("Could not delete temporal input directory: " + temporalInputDir, e);
+            logger.warn("Could not delete temporal input directory: " + temporalInputDir, e);
         }
         // Delete temporal files and folders created by nextflow
         try (Stream<Path> paths = Files.walk(getOutDir().resolve(".nextflow"))) {
@@ -324,14 +324,14 @@ private void deleteTemporalFiles() {
                     .map(Path::toFile)
                     .forEach(java.io.File::delete);
         } catch (IOException e) {
-            logger.error("Could not delete temporal nextflow directory: " + getOutDir().resolve(".nextflow"), e);
+            logger.warn("Could not delete temporal nextflow directory: " + getOutDir().resolve(".nextflow"), e);
         }
         try (Stream<Path> paths = Files.walk(getOutDir().resolve("work"))) {
             paths.sorted(Comparator.reverseOrder())
                     .map(Path::toFile)
                     .forEach(java.io.File::delete);
         } catch (IOException e) {
-            logger.error("Could not delete temporal work directory: " + getOutDir().resolve("work"), e);
+            logger.warn("Could not delete temporal work directory: " + getOutDir().resolve("work"), e);
         }
 
     }
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index abf85b4e2c9..c3de674f9fe 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -116,7 +116,7 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         StopWatch stopWatch = StopWatch.createStarted();
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
         Map<String, String> cliParams = new HashMap<>();
-        cliParams.put("input", "file://samplesheet.csv");
+//        cliParams.put("input", "file://samplesheet.csv");
 //        cliParams.put("outdir", "$OUTPUT");
 //        cliParams.put("genome", "GRCh37");
 //        cliParams.put("-profile", "docker");

From 861a87a24ef5f01350850250ab67f8474958bd38 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 1 Oct 2024 12:11:19 +0200
Subject: [PATCH 81/99] analysis: support $JOB_OUTPUT variable, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   |  2 +-
 .../opencga/catalog/utils/InputFileUtils.java | 19 ++++++++++++++-----
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 74723c16646..859c86ec8db 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -211,7 +211,7 @@ void processInputCli(String value, InputFileUtils inputFileUtils, StringBuilder
 
     }
 
-    void processOutputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) {
+    void processOutputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) throws CatalogException {
         String dynamicOutputFolder;
         if (inputFileUtils.isDynamicOutputFolder(value)) {
             // If it starts with $OUTPUT/...
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
index 25543c10f35..dfb880adf47 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/utils/InputFileUtils.java
@@ -11,6 +11,7 @@
 import java.io.*;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.regex.Matcher;
@@ -23,6 +24,7 @@ public class InputFileUtils {
     private static final Pattern OPENCGA_PATH_PATTERN = Pattern.compile("^(?i)(ocga://|opencga://|file://)(.+)$");
     private static final Pattern OPENCGA_PATH_IN_LINE_PATTERN = Pattern.compile("(?i)(ocga://|opencga://|file://)(\\S+)");
     private static final String OUTPUT = "$OUTPUT";
+    private static final List<String> OUTPUT_LIST = Arrays.asList("$OUTPUT", "$JOB_OUTPUT");
     private final Logger logger = LoggerFactory.getLogger(InputFileUtils.class);
 
     public InputFileUtils(CatalogManager catalogManager) {
@@ -97,14 +99,21 @@ public List<File> findAndReplaceFilePathToUrisFromFile(String study, File file,
     }
 
     public boolean isDynamicOutputFolder(String file) {
-        return file.toUpperCase().startsWith(OUTPUT);
+        for (String prefix : OUTPUT_LIST) {
+            if (file.toUpperCase().startsWith(prefix)) {
+                return true;
+            }
+        }
+        return false;
     }
 
-    public String getDynamicOutputFolder(String file, String outDir) {
-        if (!isDynamicOutputFolder(file)) {
-            return file;
+    public String getDynamicOutputFolder(String file, String outDir) throws CatalogException {
+        for (String prefix : OUTPUT_LIST) {
+            if (file.toUpperCase().startsWith(prefix)) {
+                return outDir + file.substring(prefix.length());
+            }
         }
-        return outDir + file.substring(OUTPUT.length());
+        throw new CatalogException("Unexpected error. File '" + file + "' is not a dynamic output folder");
     }
 
     public String appendSubpath(String path, String subpath) {

From bc2cc11b337314eac2cca246b6f45168cbff99fa Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 1 Oct 2024 14:55:19 +0200
Subject: [PATCH 82/99] analysis: add new OpenCgaDockerTool, #TASK-6445

---
 .../customTool/CustomToolExecutor.java        |  41 +----
 .../tools/OpenCgaDockerToolScopeStudy.java    | 157 ++++++++++++++++++
 .../analysis/tools/OpenCgaToolScopeStudy.java |  13 --
 .../analysis/workflow/NextFlowExecutor.java   | 106 ++----------
 .../analysis/tools/WorkflowExecutorTest.java  |   2 +-
 5 files changed, 176 insertions(+), 143 deletions(-)
 create mode 100644 opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaDockerToolScopeStudy.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
index c6dd60bc323..041b195d842 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
@@ -2,13 +2,10 @@
 
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.time.StopWatch;
-import org.opencb.commons.utils.DockerUtils;
-import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
-import org.opencb.opencga.catalog.utils.InputFileUtils;
+import org.opencb.opencga.analysis.tools.OpenCgaDockerToolScopeStudy;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
-import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.job.JobRunDockerParams;
 import org.opencb.opencga.core.models.job.JobRunParams;
 import org.opencb.opencga.core.models.job.ToolInfoExecutor;
@@ -17,12 +14,11 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.*;
+import java.util.LinkedList;
+import java.util.List;
 
 @Tool(id = CustomToolExecutor.ID, resource = Enums.Resource.JOB, description = CustomToolExecutor.DESCRIPTION)
-public class CustomToolExecutor extends OpenCgaToolScopeStudy {
+public class CustomToolExecutor extends OpenCgaDockerToolScopeStudy {
 
     public final static String ID = "custom-tool";
     public static final String DESCRIPTION = "Execute an analysis from a custom binary.";
@@ -31,8 +27,6 @@ public class CustomToolExecutor extends OpenCgaToolScopeStudy {
     protected JobRunParams runParams = new JobRunParams();
 
     private String cliParams;
-    // Build list of inputfiles in case we need to specifically mount them in read only mode
-    List<AbstractMap.SimpleEntry<String, String>> inputBindings;
     private String dockerImage;
 
     private final static Logger logger = LoggerFactory.getLogger(CustomToolExecutor.class);
@@ -66,38 +60,15 @@ protected void check() throws Exception {
         tags.add(this.dockerImage);
         updateJobInformation(tags, toolInfoExecutor);
 
-        // Build input bindings
-        this.inputBindings = new LinkedList<>();
-        InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
-
         StringBuilder cliParamsBuilder = new StringBuilder();
-        String[] params = runParams.getCommandLine().split(" ");
-        Map<String, String> inputDirectoryMounts = new HashMap<>();
-        for (String param : params) {
-            if (inputFileUtils.isValidOpenCGAFile(param)) {
-                File file = inputFileUtils.findOpenCGAFileFromPattern(study, param, token);
-                Path parent = Paths.get(file.getUri()).getParent();
-                if (!inputDirectoryMounts.containsKey(parent.toString())) {
-                    inputDirectoryMounts.put(parent.toString(), "/data/input" + inputDirectoryMounts.size());
-                }
-                String directoryMount = inputDirectoryMounts.get(parent.toString());
-                inputBindings.add(new AbstractMap.SimpleEntry<>(parent.toString(), directoryMount));
-                cliParamsBuilder.append(directoryMount).append("/").append(file.getName()).append(" ");
-            } else {
-                cliParamsBuilder.append(param).append(" ");
-            }
-        }
+        processInputParams(runParams.getCommandLine(), cliParamsBuilder);
         this.cliParams = cliParamsBuilder.toString();
     }
 
     @Override
     protected void run() throws Exception {
-        // Build output binding
-        AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(getOutDir().toAbsolutePath().toString(),
-                "/data/output");
-
         StopWatch stopWatch = StopWatch.createStarted();
-        String cmdline = DockerUtils.run(dockerImage, inputBindings, outputBinding, cliParams, null);
+        String cmdline = runDocker(dockerImage, cliParams);
         logger.info("Docker command line: " + cmdline);
         logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
     }
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaDockerToolScopeStudy.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaDockerToolScopeStudy.java
new file mode 100644
index 00000000000..28bb233087a
--- /dev/null
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaDockerToolScopeStudy.java
@@ -0,0 +1,157 @@
+package org.opencb.opencga.analysis.tools;
+
+import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.commons.datastore.core.QueryOptions;
+import org.opencb.commons.utils.DockerUtils;
+import org.opencb.opencga.catalog.db.api.JobDBAdaptor;
+import org.opencb.opencga.catalog.exceptions.CatalogException;
+import org.opencb.opencga.catalog.utils.InputFileUtils;
+import org.opencb.opencga.core.models.file.File;
+import org.opencb.opencga.core.models.job.ToolInfoExecutor;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.stream.Stream;
+
+public abstract class OpenCgaDockerToolScopeStudy extends OpenCgaToolScopeStudy {
+
+    // Build list of inputfiles in case we need to specifically mount them in read only mode
+    protected List<AbstractMap.SimpleEntry<String, String>> dockerInputBindings;
+    // Directory where temporal input files will be stored
+    protected Path temporalInputDir;
+
+    protected InputFileUtils inputFileUtils;
+
+    @Override
+    protected void check() throws Exception {
+        super.check();
+        this.dockerInputBindings = new LinkedList<>();
+        this.temporalInputDir = Files.createDirectory(getOutDir().resolve(".opencga_input"));
+        this.inputFileUtils = new InputFileUtils(catalogManager);
+    }
+
+    @Override
+    protected void close() {
+        super.close();
+        deleteTemporalFiles();
+    }
+
+    private void deleteTemporalFiles() {
+        // Delete input files and temporal directory
+        try (Stream<Path> paths = Files.walk(temporalInputDir)) {
+            paths.sorted(Comparator.reverseOrder())
+                    .map(Path::toFile)
+                    .forEach(java.io.File::delete);
+        } catch (IOException e) {
+            logger.warn("Could not delete temporal input directory: " + temporalInputDir, e);
+        }
+    }
+
+    /**
+     * Process the input parameters of the command line.
+     * @param value
+     * @param inputFileUtils
+     * @param cliParamsBuilder
+     * @throws CatalogException
+     */
+    protected void processInputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) throws CatalogException {
+        if (inputFileUtils.isValidOpenCGAFile(value)) {
+            File file = inputFileUtils.findOpenCGAFileFromPattern(study, value, token);
+            if (inputFileUtils.fileMayContainReferencesToOtherFiles(file)) {
+                Path outputFile = temporalInputDir.resolve(file.getName());
+                List<File> files = inputFileUtils.findAndReplaceFilePathToUrisFromFile(study, file, outputFile, token);
+
+                // Write outputFile as inputBinding
+                dockerInputBindings.add(new AbstractMap.SimpleEntry<>(outputFile.toString(), outputFile.toString()));
+                logger.info("Params: OpenCGA input file: '{}'", outputFile);
+                cliParamsBuilder.append(outputFile).append(" ");
+
+                // Add files to inputBindings to ensure they are also mounted (if any)
+                for (File tmpFile : files) {
+                    dockerInputBindings.add(new AbstractMap.SimpleEntry<>(tmpFile.getUri().getPath(), tmpFile.getUri().getPath()));
+                    logger.info("Inner files from '{}': OpenCGA input file: '{}'", outputFile, tmpFile.getUri().getPath());
+                }
+            } else {
+                String path = file.getUri().getPath();
+                dockerInputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
+                logger.info("Params: OpenCGA input file: '{}'", path);
+                cliParamsBuilder.append(path).append(" ");
+            }
+        } else {
+            cliParamsBuilder.append(value).append(" ");
+        }
+
+    }
+
+    protected void processOutputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) throws CatalogException {
+        String dynamicOutputFolder;
+        if (inputFileUtils.isDynamicOutputFolder(value)) {
+            // If it starts with $OUTPUT/...
+            dynamicOutputFolder = inputFileUtils.getDynamicOutputFolder(value, getOutDir().toAbsolutePath().toString());
+        } else {
+            // If it starts directly with the subpath...
+            dynamicOutputFolder = inputFileUtils.appendSubpath(getOutDir().toAbsolutePath().toString(), value);
+        }
+        logger.info("Params: Dynamic output folder: '{}'", dynamicOutputFolder);
+        cliParamsBuilder.append(dynamicOutputFolder).append(" ");
+    }
+
+    /**
+     * Given a variable name, it removes the prefix '-' if present.
+     * Example: --input -> input; -input -> input; input -> input
+     *
+     * @param variable A parameter of a command line.
+     * @return the variable removing any '-' prefix.
+     */
+    protected String removePrefix(String variable) {
+        String value = variable;
+        while (value.startsWith("-")) {
+            value = value.substring(1);
+        }
+        return value;
+    }
+
+    protected void updateJobInformation(List<String> tags, ToolInfoExecutor executor) throws CatalogException {
+        ObjectMap params = new ObjectMap()
+                .append(JobDBAdaptor.QueryParams.TAGS.key(), tags)
+                .append(JobDBAdaptor.QueryParams.TOOL_EXTERNAL_EXECUTOR.key(), executor);
+        catalogManager.getJobManager().update(getStudyFqn(), getJobId(), params, QueryOptions.empty(), token);
+    }
+
+    protected void processInputParams(String commandLineParams, StringBuilder builder) throws CatalogException {
+        String[] params = commandLineParams.split(" ");
+        for (String param : params) {
+            if (inputFileUtils.isDynamicOutputFolder(param)) {
+                processOutputCli(param, inputFileUtils, builder);
+            } else {
+                processInputCli(param, inputFileUtils, builder);
+            }
+        }
+    }
+
+    protected String runDocker(String image, String cli) throws IOException {
+        return runDocker(image, null, cli, null);
+    }
+
+    protected String runDocker(String image, AbstractMap.SimpleEntry<String, String> userOutputBinding, String cmdParams,
+                               Map<String, String> userDockerParams) throws IOException {
+        AbstractMap.SimpleEntry<String, String> outputBinding = userOutputBinding != null
+                ? userOutputBinding
+                : new AbstractMap.SimpleEntry<>(getOutDir().toAbsolutePath().toString(), getOutDir().toAbsolutePath().toString());
+
+        Map<String, String> dockerParams = new HashMap<>();
+        // Establish working directory
+        dockerParams.put("-w", getOutDir().toAbsolutePath().toString());
+        dockerParams.put("--volume", "/var/run/docker.sock:/var/run/docker.sock");
+        dockerParams.put("--env", "DOCKER_HOST='tcp://localhost:2375'");
+        dockerParams.put("--network", "host");
+        if (userDockerParams != null) {
+            dockerParams.putAll(userDockerParams);
+        }
+
+        return DockerUtils.run(image, dockerInputBindings, outputBinding, cmdParams, dockerParams);
+    }
+
+}
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
index 9e49423c7eb..016ffa32058 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaToolScopeStudy.java
@@ -16,15 +16,9 @@
 
 package org.opencb.opencga.analysis.tools;
 
-import org.opencb.commons.datastore.core.ObjectMap;
-import org.opencb.commons.datastore.core.QueryOptions;
-import org.opencb.opencga.catalog.db.api.JobDBAdaptor;
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.managers.StudyManager;
 import org.opencb.opencga.core.api.ParamConstants;
-import org.opencb.opencga.core.models.job.ToolInfoExecutor;
-
-import java.util.List;
 
 public abstract class OpenCgaToolScopeStudy extends OpenCgaTool {
 
@@ -56,11 +50,4 @@ protected final String getStudyFqn() throws CatalogException {
                 getToken()).first().getFqn();
     }
 
-    protected void updateJobInformation(List<String> tags, ToolInfoExecutor executor) throws CatalogException {
-        ObjectMap params = new ObjectMap()
-                .append(JobDBAdaptor.QueryParams.TAGS.key(), tags)
-                .append(JobDBAdaptor.QueryParams.TOOL_EXTERNAL_EXECUTOR.key(), executor);
-        catalogManager.getJobManager().update(getStudyFqn(), getJobId(), params, QueryOptions.empty(), token);
-    }
-
 }
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 859c86ec8db..45779ccf391 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -9,16 +9,13 @@
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.commons.datastore.core.Query;
 import org.opencb.commons.datastore.core.QueryOptions;
-import org.opencb.commons.utils.DockerUtils;
-import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
+import org.opencb.opencga.analysis.tools.OpenCgaDockerToolScopeStudy;
 import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
-import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.utils.InputFileUtils;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
-import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.job.ToolInfoExecutor;
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
@@ -43,7 +40,7 @@
 import java.util.stream.Stream;
 
 @Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.WORKFLOW, description = NextFlowExecutor.DESCRIPTION)
-public class NextFlowExecutor extends OpenCgaToolScopeStudy {
+public class NextFlowExecutor extends OpenCgaDockerToolScopeStudy {
 
     public final static String ID = "workflow";
     public static final String DESCRIPTION = "Execute a Nextflow analysis.";
@@ -54,11 +51,6 @@ public class NextFlowExecutor extends OpenCgaToolScopeStudy {
     private Workflow workflow;
     private String cliParams;
 
-    // Build list of inputfiles in case we need to specifically mount them in read only mode
-    List<AbstractMap.SimpleEntry<String, String>> inputBindings;
-
-    private Path temporalInputDir;
-    private Map<String, String> dockerParams;
     private String outDirPath;
 
     private Thread thread;
@@ -76,9 +68,6 @@ protected void check() throws Exception {
 
         InputFileUtils inputFileUtils = new InputFileUtils(catalogManager);
 
-        dockerParams = new HashMap<>();
-        temporalInputDir = Files.createDirectory(getOutDir().resolve(".opencga_input"));
-
         OpenCGAResult<Workflow> result;
         if (nextflowParams.getVersion() != null) {
             Query query = new Query(WorkflowDBAdaptor.QueryParams.VERSION.key(), nextflowParams.getVersion());
@@ -120,12 +109,10 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
-        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
+//        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
 
         StringBuilder cliParamsBuilder = new StringBuilder();
-        this.inputBindings = new LinkedList<>();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
-
             for (Map.Entry<String, String> entry : nextflowParams.getParams().entrySet()) {
                 String variableId = removePrefix(entry.getKey());
                 // Remove from the mandatoryParams set
@@ -182,70 +169,13 @@ protected void check() throws Exception {
         this.cliParams = cliParamsBuilder.toString();
     }
 
-    void processInputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) throws CatalogException {
-        if (inputFileUtils.isValidOpenCGAFile(value)) {
-            File file = inputFileUtils.findOpenCGAFileFromPattern(study, value, token);
-            if (inputFileUtils.fileMayContainReferencesToOtherFiles(file)) {
-                Path outputFile = temporalInputDir.resolve(file.getName());
-                List<File> files = inputFileUtils.findAndReplaceFilePathToUrisFromFile(study, file, outputFile, token);
-
-                // Write outputFile as inputBinding
-                inputBindings.add(new AbstractMap.SimpleEntry<>(outputFile.toString(), outputFile.toString()));
-                logger.info("Params: OpenCGA input file: '{}'", outputFile);
-                cliParamsBuilder.append(outputFile).append(" ");
-
-                // Add files to inputBindings to ensure they are also mounted (if any)
-                for (File tmpFile : files) {
-                    inputBindings.add(new AbstractMap.SimpleEntry<>(tmpFile.getUri().getPath(), tmpFile.getUri().getPath()));
-                    logger.info("Inner files from '{}': OpenCGA input file: '{}'", outputFile, tmpFile.getUri().getPath());
-                }
-            } else {
-                String path = file.getUri().getPath();
-                inputBindings.add(new AbstractMap.SimpleEntry<>(path, path));
-                logger.info("Params: OpenCGA input file: '{}'", path);
-                cliParamsBuilder.append(path).append(" ");
-            }
-        } else {
-            cliParamsBuilder.append(value).append(" ");
-        }
-
-    }
-
-    void processOutputCli(String value, InputFileUtils inputFileUtils, StringBuilder cliParamsBuilder) throws CatalogException {
-        String dynamicOutputFolder;
-        if (inputFileUtils.isDynamicOutputFolder(value)) {
-            // If it starts with $OUTPUT/...
-            dynamicOutputFolder = inputFileUtils.getDynamicOutputFolder(value, outDirPath);
-        } else {
-            // If it starts directly with the subpath...
-            dynamicOutputFolder = inputFileUtils.appendSubpath(outDirPath, value);
-        }
-        logger.info("Params: Dynamic output folder: '{}'", dynamicOutputFolder);
-        cliParamsBuilder.append(dynamicOutputFolder).append(" ");
-    }
-
-    /**
-     * Given a variable name, it removes the prefix '-' if present.
-     * Example: --input -> input; -input -> input; input -> input
-     *
-     * @param variable A parameter of the nextflow command line.
-     * @return the variable removing any '-' prefix.
-     */
-    private String removePrefix(String variable) {
-        String value = variable;
-        while (value.startsWith("-")) {
-            value = value.substring(1);
-        }
-        return value;
-    }
-
     @Override
     protected void run() throws Exception {
         for (WorkflowScript script : workflow.getScripts()) {
             // Write script files
             Path path = temporalInputDir.resolve(script.getFileName());
             Files.write(path, script.getContent().getBytes());
-            inputBindings.add(new AbstractMap.SimpleEntry<>(path.toString(), path.toString()));
+            dockerInputBindings.add(new AbstractMap.SimpleEntry<>(path.toString(), path.toString()));
         }
 
         // Write nextflow.config file
@@ -254,17 +184,11 @@ protected void run() throws Exception {
         if (nextflowConfig != null) {
             nextflowConfigPath = temporalInputDir.resolve("nextflow.config");
             Files.copy(nextflowConfig.openStream(), nextflowConfigPath);
-            inputBindings.add(new AbstractMap.SimpleEntry<>(nextflowConfigPath.toString(), nextflowConfigPath.toString()));
+            dockerInputBindings.add(new AbstractMap.SimpleEntry<>(nextflowConfigPath.toString(), nextflowConfigPath.toString()));
         } else {
             throw new RuntimeException("Can't fetch nextflow.config file");
         }
 
-        // Establish working directory
-        dockerParams.put("-w", outDirPath);
-        // Set HOME environment variable to the temporal input directory. This is because nextflow creates a hidden folder there and,
-        // when nextflow runs on other dockers, we need to store those files in a path shared between the parent docker and the host
-        dockerParams.put("-e", "HOME=" + temporalInputDir);
-
         // Build output binding
         AbstractMap.SimpleEntry<String, String> outputBinding = new AbstractMap.SimpleEntry<>(outDirPath, outDirPath);
 
@@ -274,9 +198,6 @@ protected void run() throws Exception {
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getImage());
-            dockerParams.put("--volume", "/var/run/docker.sock:/var/run/docker.sock");
-            dockerParams.put("--env", "DOCKER_HOST='tcp://localhost:2375'");
-            dockerParams.put("--network", "host");
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {
@@ -292,9 +213,14 @@ protected void run() throws Exception {
 
         startTraceFileMonitor();
 
+        Map<String, String> dockerParams = new HashMap<>();
+        // Set HOME environment variable to the temporal input directory. This is because nextflow creates a hidden folder there and,
+        // when nextflow runs on other dockers, we need to store those files in a path shared between the parent docker and the host
+        dockerParams.put("-e", "HOME=" + temporalInputDir);
+
         // Execute docker image
         StopWatch stopWatch = StopWatch.createStarted();
-        DockerUtils.run(dockerImage, inputBindings, outputBinding, stringBuilder.toString(), dockerParams);
+        runDocker(dockerImage, outputBinding, stringBuilder.toString(), dockerParams);
         logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
     }
 
@@ -305,19 +231,12 @@ protected void finalize() throws Throwable {
 
     @Override
     protected void close() {
+        super.close();
         endTraceFileMonitor();
         deleteTemporalFiles();
     }
 
     private void deleteTemporalFiles() {
-        // Delete input files and temporal directory
-        try (Stream<Path> paths = Files.walk(temporalInputDir)) {
-            paths.sorted(Comparator.reverseOrder())
-                    .map(Path::toFile)
-                    .forEach(java.io.File::delete);
-        } catch (IOException e) {
-            logger.warn("Could not delete temporal input directory: " + temporalInputDir, e);
-        }
         // Delete temporal files and folders created by nextflow
         try (Stream<Path> paths = Files.walk(getOutDir().resolve(".nextflow"))) {
             paths.sorted(Comparator.reverseOrder())
@@ -333,7 +252,6 @@ private void deleteTemporalFiles() {
         } catch (IOException e) {
             logger.warn("Could not delete temporal work directory: " + getOutDir().resolve("work"), e);
         }
-
     }
 
     protected void endTraceFileMonitor() {
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
index c3de674f9fe..abf85b4e2c9 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/tools/WorkflowExecutorTest.java
@@ -116,7 +116,7 @@ public void nextflowDockerTest() throws ToolException, CatalogException, IOExcep
         StopWatch stopWatch = StopWatch.createStarted();
         NextFlowExecutor nextFlowExecutorTest = new NextFlowExecutor();
         Map<String, String> cliParams = new HashMap<>();
-//        cliParams.put("input", "file://samplesheet.csv");
+        cliParams.put("input", "file://samplesheet.csv");
 //        cliParams.put("outdir", "$OUTPUT");
 //        cliParams.put("genome", "GRCh37");
 //        cliParams.put("-profile", "docker");

From ccbba0079f41121ac8a8ae4288762f0f43e4712c Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Thu, 3 Oct 2024 13:40:39 +0100
Subject: [PATCH 83/99] app: docker improvements

---
 .../liftover/LiftoverWrapperAnalysis.java     | 30 +++++++++------
 .../LiftoverWrapperAnalysisExecutor.java      | 18 +++++++--
 opencga-app/app/analysis/liftover/liftover.sh |  5 ++-
 .../cloud/docker/opencga-ext-tools/Dockerfile | 38 +++++++------------
 .../models/variant/LiftoverWrapperParams.java | 30 +++++++++++----
 5 files changed, 71 insertions(+), 50 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysis.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysis.java
index 81caf856e8a..91b118da9ef 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysis.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysis.java
@@ -17,11 +17,9 @@
 package org.opencb.opencga.analysis.wrappers.liftover;
 
 
-import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.opencb.opencga.analysis.tools.OpenCgaToolScopeStudy;
-import org.opencb.opencga.analysis.variant.manager.CatalogUtils;
-import org.opencb.opencga.analysis.wrappers.plink.PlinkWrapperAnalysisExecutor;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.variant.LiftoverWrapperParams;
@@ -40,17 +38,23 @@ public class LiftoverWrapperAnalysis extends OpenCgaToolScopeStudy {
     protected void check() throws Exception {
         super.check();
 
-        if (StringUtils.isEmpty(analysisParams.getFile())) {
+        if (CollectionUtils.isEmpty(analysisParams.getFiles())) {
             throw new ToolException("Liftover 'file' parameter is mandatory.");
         }
 
-        if (StringUtils.isEmpty(analysisParams.getOutdir())) {
-            String file = analysisParams.getFile();
-            if (file.contains("/")) {
-                analysisParams.setOutdir(file.substring(0, file.lastIndexOf('/')));
-            } else {
-                analysisParams.setOutdir("");
-            }
+        if (StringUtils.isEmpty(analysisParams.getTargetAssembly())) {
+            throw new ToolException("Liftover 'targetDirectory' parameter is mandatory, valid options are 'GRCh38' and 'hg38'.");
+        }
+
+        if (StringUtils.isEmpty(analysisParams.getVcfOutdir())) {
+//            String file = analysisParams.getFiles();
+//            if (file.contains("/")) {
+//                // Set output directory to the parent directory of the input file
+//                analysisParams.setOutdir(file.substring(0, file.lastIndexOf('/')));
+//            } else {
+//                // Set output directory to the study root directory
+//                analysisParams.setOutdir("");
+//            }
         }
     }
 
@@ -59,9 +63,11 @@ protected void run() throws Exception {
 //        setUpStorageEngineExecutor(study);
 
         step(() -> {
+            executorParams.append("opencgaHome", getOpencgaHome().toString());
             executorParams.append("study", study);
-            executorParams.append("file", analysisParams.getFile());
+            executorParams.append("files", analysisParams.getFiles());
             executorParams.append("targetAssembly", analysisParams.getTargetAssembly());
+            executorParams.append("vcfOutdir", analysisParams.getVcfOutdir());
             executorParams.append("outdir", analysisParams.getOutdir());
 
             getToolExecutor(LiftoverWrapperAnalysisExecutor.class)
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysisExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysisExecutor.java
index 0902de118f2..fe3c8ecfa62 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysisExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/wrappers/liftover/LiftoverWrapperAnalysisExecutor.java
@@ -1,5 +1,7 @@
 package org.opencb.opencga.analysis.wrappers.liftover;
 
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.tuple.ImmutablePair;
 import org.apache.commons.lang3.tuple.Pair;
 import org.opencb.opencga.analysis.wrappers.executors.DockerWrapperAnalysisExecutor;
@@ -8,6 +10,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.File;
 import java.util.*;
 
 @ToolExecutor(id = LiftoverWrapperAnalysisExecutor.ID,
@@ -26,13 +29,22 @@ public class LiftoverWrapperAnalysisExecutor extends DockerWrapperAnalysisExecut
     protected void run() throws Exception {
         StringBuilder sb = initCommandLine();
 
-        // Append mounts
+        // 1. Wrapper analysis sets the path to the liftover executable
+        Object liftoverPath = getExecutorParams().get("liftoverPath");
+        if (StringUtils.isEmpty(liftoverPath.toString())) {
+            throw new IllegalArgumentException("Missing liftoverPath parameter");
+        }
+
+        // 2. Copy liftover executable to the job output directory
+        FileUtils.copyFile(new File(liftoverPath.toString()), getOutDir().toFile());
+
+        // 3. Append mounts
         List<Pair<String, String>> inputFilenames = DockerWrapperAnalysisExecutor.getInputFilenames(null,
                 PlinkWrapperAnalysis.FILE_PARAM_NAMES, getExecutorParams());
         Map<String, String> mountMap = appendMounts(inputFilenames, sb);
 
         // Append docker image, version and command
-        appendCommand("bcftools +liftover", sb);
+        appendCommand("liftover.sh", sb);
 
         // Append input file params
         appendInputFiles(inputFilenames, mountMap, sb);
@@ -47,7 +59,7 @@ protected void run() throws Exception {
         appendOtherParams(skipParams, sb);
 
         // Execute command and redirect stdout and stderr to the files
-        logger.info("Docker command line: " + sb.toString());
+        logger.info("Docker command line: {}", sb);
         runCommandLine(sb.toString());
     }
 
diff --git a/opencga-app/app/analysis/liftover/liftover.sh b/opencga-app/app/analysis/liftover/liftover.sh
index b737186a5cb..7a7a3c83645 100644
--- a/opencga-app/app/analysis/liftover/liftover.sh
+++ b/opencga-app/app/analysis/liftover/liftover.sh
@@ -17,7 +17,7 @@
 #/bin/bash
 
 INPUT_FILE=$1
-TARGET_ASSEMBLY=$2
+TARGET_ASSEMBLY=$2  ## Values accepted are: GRCh38, hg38
 OUTPUT_FILE=$3
 
 if [ -z "$INPUT_FILE" ] || [ -z "$TARGET_ASSEMBLY" ] || [ -z "$OUTPUT_FILE" ]; then
@@ -74,5 +74,6 @@ fi
 bcftools +liftover --no-version -Oz $INPUT_FILE -- -s $SOURCE_REFERENCE_FILE -f $TARGET_REFERENCE_FILE -c $CHAIN_FILE --reject rejected.vcf --reject-type v --write-reject --write-src > $OUTPUT_FILE
 
 ## Clean folders
+rm *.fa
 rm *.fai
-rm *.chain.gz
\ No newline at end of file
+rm *.chain.gz
diff --git a/opencga-app/app/cloud/docker/opencga-ext-tools/Dockerfile b/opencga-app/app/cloud/docker/opencga-ext-tools/Dockerfile
index a01df67c0ff..9b200a844b2 100644
--- a/opencga-app/app/cloud/docker/opencga-ext-tools/Dockerfile
+++ b/opencga-app/app/cloud/docker/opencga-ext-tools/Dockerfile
@@ -1,4 +1,4 @@
-FROM debian:bullseye
+FROM ubuntu:22.04
 
 LABEL org.label-schema.vendor="OpenCB" \
       org.label-schema.name="opencga-ext-tools" \
@@ -7,31 +7,31 @@ LABEL org.label-schema.vendor="OpenCB" \
       maintainer="Joaquin Tarraga <joaquintarraga@gmail.com>" \
       org.label-schema.schema-version="1.0"
 
-# WORKDIR /opt/opencga/signature.tools.lib
-
-# run update and install necessary packages
+## Run update and install necessary packages
 RUN apt-get update -y && \
     ## 1. Install system dependencies
-    DEBIAN_FRONTEND="noninteractive" TZ="Europe/London" apt-get install -y libcurl4 git libgmp-dev libcurl4-openssl-dev libgit2-dev \
+    DEBIAN_FRONTEND="noninteractive" TZ="Europe/London" apt-get install -y libcurl4 git libgmp-dev libcurl4-openssl-dev libgit2-dev build-essential \
     libssl-dev libssh-dev libxml2-dev libfontconfig1-dev libharfbuzz-dev libfribidi-dev libfreetype6-dev libpng-dev libtiff5-dev libjpeg-dev \
-    gnuplot pandoc samtools bcftools tabix fastqc plink1.9 bwa r-base && \
+    gnuplot pandoc samtools bcftools tabix fastqc plink1.9 bwa r-base wget libopenblas0-openmp libcholmod3 libsuitesparse-dev && \
+    apt-get remove libopenblas0-pthread && \
 
     ## 2. Install samtools and bcftools 1.21 and plugins
+#     apt-get update -y && apt-get install -y wget && \
     wget https://github.com/samtools/samtools/releases/download/1.21/samtools-1.21.tar.bz2 && \
     tar xjvf samtools-1.21.tar.bz2 && \
     cd samtools-1.21 && \
-    ./configure --prefix=/usr/local/bin && \
+    ./configure --prefix=/usr/local && \
     make && make install && \
     cd .. && \
 
     wget http://github.com/samtools/bcftools/releases/download/1.21/bcftools-1.21.tar.bz2 && \
     tar xjvf bcftools-1.21.tar.bz2 && \
-    wget -P bcftools-1.21 http://raw.githubusercontent.com/DrTimothyAldenDavis/SuiteSparse/stable/{SuiteSparse_config/SuiteSparse_config,CHOLMOD/Include/cholmod}.h && \
+    bash -c 'wget -P bcftools-1.21 http://raw.githubusercontent.com/DrTimothyAldenDavis/SuiteSparse/stable/{SuiteSparse_config/SuiteSparse_config,CHOLMOD/Include/cholmod}.h' && \
     cd bcftools-1.21/ && \
-    /bin/rm -f plugins/{score.{c,h},{munge,liftover,metal,blup}.c,pgs.{c,mk}} && \
-    wget -P plugins http://raw.githubusercontent.com/freeseek/score/master/{score.{c,h},{munge,liftover,metal,blup}.c,pgs.{c,mk}} && \
+    bash -c '/bin/rm -f plugins/{score.{c,h},{munge,liftover,metal,blup}.c,pgs.{c,mk}}' && \
+    bash -c 'wget -P plugins http://raw.githubusercontent.com/freeseek/score/master/{score.{c,h},{munge,liftover,metal,blup}.c,pgs.{c,mk}}' && \
     make && \
-    /bin/cp bcftools plugins/{munge,liftover,score,metal,pgs,blup}.so /usr/local/bin/ && \
+    bash -c '/bin/cp bcftools plugins/{munge,liftover,score,metal,pgs,blup}.so /usr/local/bin/' && \
     wget -P /usr/local/bin http://raw.githubusercontent.com/freeseek/score/master/assoc_plot.R && \
     chmod a+x /usr/local/bin/assoc_plot.R && \
     cd .. && \
@@ -42,7 +42,7 @@ RUN apt-get update -y && \
     R -e "BiocManager::install('BSgenome.Hsapiens.UCSC.hg38')" && \
 
     ## 4. Install signature.tools.lib installation \
-    R -e 'install.packages(c("devtools", "getopt"), repos=c("http://cran.rstudio.com/", "https://www.stats.bris.ac.uk/R/"))' && \
+    R -e "install.packages(c('devtools', 'getopt'), repos=c('http://cran.rstudio.com/', 'https://www.stats.bris.ac.uk/R/'))" && \
     git clone https://github.com/Nik-Zainal-Group/signature.tools.lib.git /opt/opencga/signature.tools.lib && \
     cd /opt/opencga/signature.tools.lib && \
     git fetch origin --tags && \
@@ -50,25 +50,13 @@ RUN apt-get update -y && \
     sed -i '/Mmusculus/d' DESCRIPTION && \
     sed -i '/Cfamiliaris/d' DESCRIPTION && \
     sed -i '/1000genomes/d' DESCRIPTION && \
-    R -e 'options(timeout = 3600);devtools::install(repos="https://www.stats.bris.ac.uk/R/")' && \
+    R -e "options(timeout = 3600);devtools::install(repos='https://www.stats.bris.ac.uk/R/')" && \
     cd .. && \
 
     ## 5. Clean up
     rm -rf samtools-1.21 bcftools-1.21 /var/lib/apt/lists/* /tmp/* /opt/opencga/signature.tools.lib/.git && \
     strip --remove-section=.note.ABI-tag /usr/lib/x86_64-linux-gnu/libQt5Core.so.5
 
-# WORKDIR /opt/opencga/signature.tools.lib
-
-# RUN git fetch origin --tags && \
-#     git checkout tags/v2.4.4 && \
-#     sed -i '/Mmusculus/d' DESCRIPTION && \
-#     sed -i '/Cfamiliaris/d' DESCRIPTION && \
-#     sed -i '/1000genomes/d' DESCRIPTION && \
-#     R -e 'options(timeout = 3600);devtools::install(repos="https://www.stats.bris.ac.uk/R/")' && \
-#     ## Clean up
-#     rm -rf /var/lib/apt/lists/* /tmp/* /opt/opencga/signature.tools.lib/.git && \
-#     strip --remove-section=.note.ABI-tag /usr/lib/x86_64-linux-gnu/libQt5Core.so.5
-
 ENV BCFTOOLS_PLUGINS="/usr/local/bin"
 
 WORKDIR /opt/opencga
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/variant/LiftoverWrapperParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/variant/LiftoverWrapperParams.java
index f8ea4391ced..5e0ac80179b 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/variant/LiftoverWrapperParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/variant/LiftoverWrapperParams.java
@@ -18,39 +18,44 @@
 
 import org.opencb.opencga.core.tools.ToolParams;
 
+import java.util.List;
+
 public class LiftoverWrapperParams extends ToolParams {
 
     public static final String DESCRIPTION = "BCFtools +liftover plugin params";
 
-    private String file;
+    private List<String> files;
     private String targetAssembly;
+    private String vcfOutdir;
     private String outdir;
 
     public LiftoverWrapperParams() {
     }
 
-    public LiftoverWrapperParams(String file, String targetAssembly, String outdir) {
-        this.file = file;
+    public LiftoverWrapperParams(List<String> files, String targetAssembly, String vcfOutdir, String outdir) {
+        this.files = files;
         this.targetAssembly = targetAssembly;
+        this.vcfOutdir = vcfOutdir;
         this.outdir = outdir;
     }
 
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("LiftoverWrapperParams{");
-        sb.append("file='").append(file).append('\'');
+        sb.append("files=").append(files);
         sb.append(", targetAssembly='").append(targetAssembly).append('\'');
+        sb.append(", vcfOutdir='").append(vcfOutdir).append('\'');
         sb.append(", outdir='").append(outdir).append('\'');
         sb.append('}');
         return sb.toString();
     }
 
-    public String getFile() {
-        return file;
+    public List<String> getFiles() {
+        return files;
     }
 
-    public LiftoverWrapperParams setFile(String file) {
-        this.file = file;
+    public LiftoverWrapperParams setFiles(List<String> files) {
+        this.files = files;
         return this;
     }
 
@@ -63,6 +68,15 @@ public LiftoverWrapperParams setTargetAssembly(String targetAssembly) {
         return this;
     }
 
+    public String getVcfOutdir() {
+        return vcfOutdir;
+    }
+
+    public LiftoverWrapperParams setVcfOutdir(String vcfOutdir) {
+        this.vcfOutdir = vcfOutdir;
+        return this;
+    }
+
     public String getOutdir() {
         return outdir;
     }

From 7530deffbaf723f9ca293ec91d8de031c29fb4e0 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 17 Oct 2024 16:06:19 +0200
Subject: [PATCH 84/99] catalog: fix workflow permission check, #TASK-6445

---
 .../opencb/opencga/catalog/managers/WorkflowManager.java   | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index e6b443889b6..5f41792868b 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -192,14 +192,15 @@ public OpenCGAResult<Workflow> update(String studyStr, String workflowId, Workfl
             studyId = study.getId();
             studyUuid = study.getUuid();
 
-            // 1. Check permissions
-            authorizationManager.checkIsAtLeastOrganizationOwnerOrAdmin(organizationId, userId);
-
             Workflow workflow = internalGet(organizationId, study.getUid(), Collections.singletonList(workflowId), null,
                     INCLUDE_WORKFLOW_IDS, userId, false).first();
             id = workflow.getId();
             uuid = workflow.getUuid();
 
+            // Check permission
+            authorizationManager.checkWorkflowPermission(organizationId, study.getUid(), workflow.getUid(), userId,
+                    WorkflowPermissions.WRITE);
+
             if (updateParams == null) {
                 throw new CatalogException("Missing parameters to update the workflow.");
             }

From 71472c04e05f925386cdc8ba1b6ff621bcf8b8b8 Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Fri, 18 Oct 2024 11:09:49 +0100
Subject: [PATCH 85/99] core: fix Workflow variable types

---
 .../analysis/workflow/NextFlowExecutor.java    |  2 +-
 .../core/models/workflow/WorkflowVariable.java | 18 ++++++++++--------
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 45779ccf391..4a74f30d70d 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -136,7 +136,7 @@ protected void check() throws Exception {
                         cliParamsBuilder.append(workflowVariable.getDefaultValue()).append(" ");
                     } else if (workflowVariable.isOutput()) {
                         processOutputCli("", inputFileUtils, cliParamsBuilder);
-                    } else if (workflowVariable.isRequired() && workflowVariable.getType() != WorkflowVariable.WorkflowType.FLAG) {
+                    } else if (workflowVariable.isRequired() && workflowVariable.getType() != WorkflowVariable.WorkflowVariableType.FLAG) {
                         throw new ToolException("Missing value for mandatory parameter: '" + variableId + "'.");
                     }
                 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowVariable.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowVariable.java
index 27d03fc8d27..678f4bf19de 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowVariable.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowVariable.java
@@ -5,22 +5,24 @@ public class WorkflowVariable {
     private String id;
     private String name;
     private String description;
-    private WorkflowType type;
+    private WorkflowVariableType type;
     private boolean required;
     private String defaultValue;
     private boolean output;
 
-    public enum WorkflowType {
-        INT,
-        STRING,
+    public enum WorkflowVariableType {
+        FLAG,
         BOOLEAN,
-        FLAG
+        INTEGER,
+        DOUBLE,
+        STRING,
+        FILE
     }
 
     public WorkflowVariable() {
     }
 
-    public WorkflowVariable(String id, String name, String description, WorkflowType type, boolean required, String defaultValue,
+    public WorkflowVariable(String id, String name, String description, WorkflowVariableType type, boolean required, String defaultValue,
                             boolean output) {
         this.id = id;
         this.name = name;
@@ -72,11 +74,11 @@ public WorkflowVariable setDescription(String description) {
         return this;
     }
 
-    public WorkflowType getType() {
+    public WorkflowVariableType getType() {
         return type;
     }
 
-    public WorkflowVariable setType(WorkflowType type) {
+    public WorkflowVariable setType(WorkflowVariableType type) {
         this.type = type;
         return this;
     }

From fcd8f979e4ce74524b7f1d4c8e41d6608a35fbb1 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 22 Oct 2024 16:01:12 +0200
Subject: [PATCH 86/99] catalog: add new changes for workflows, #TASK-6445

---
 .../analysis/workflow/NextFlowExecutor.java   |  20 +-
 .../main/executors/JobsCommandExecutor.java   |   1 +
 .../cli/main/options/JobsCommandOptions.java  |   3 +
 .../opencga/catalog/managers/JobManager.java  |  16 +-
 .../catalog/managers/WorkflowManager.java     | 255 +++++++++++++++++-
 .../catalog/migration/MigrationManager.java   |   4 +-
 .../catalog/managers/WorkflowManagerTest.java |  18 ++
 .../opencga/core/api/FieldConstants.java      |   2 +
 .../opencga/core/api/ParamConstants.java      |   2 +
 .../opencb/opencga/core/config/Analysis.java  |  13 +-
 .../opencga/core/config/Configuration.java    |  28 ++
 .../core/config/WorkflowConfiguration.java    |  47 ++++
 .../WorkflowMinRequirementsConfiguration.java |  54 ++++
 .../config/WorkflowSystemConfiguration.java   |  42 +++
 .../opencga/core/models/job/ToolInfo.java     |  21 +-
 .../models/workflow/WorkflowImportParams.java |  42 +++
 .../workflow/WorkflowMinimumRequirements.java |  32 ++-
 .../models/workflow/WorkflowRepository.java   |  56 +++-
 .../workflow/WorkflowRepositoryParams.java    |  50 ++++
 .../src/main/resources/configuration.yml      |  10 +
 .../monitor/daemons/ExecutionDaemon.java      |  12 +-
 .../opencga/server/rest/JobWSServer.java      |   5 +-
 .../opencga/server/rest/OpenCGAWSServer.java  |  65 +++++
 .../opencga/server/rest/WorkflowWSServer.java |   3 +-
 24 files changed, 751 insertions(+), 50 deletions(-)
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowConfiguration.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowMinRequirementsConfiguration.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowSystemConfiguration.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowImportParams.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepositoryParams.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 4a74f30d70d..1766faef746 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -12,15 +12,13 @@
 import org.opencb.opencga.analysis.tools.OpenCgaDockerToolScopeStudy;
 import org.opencb.opencga.catalog.db.api.WorkflowDBAdaptor;
 import org.opencb.opencga.catalog.utils.InputFileUtils;
+import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.job.ToolInfoExecutor;
-import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
-import org.opencb.opencga.core.models.workflow.Workflow;
-import org.opencb.opencga.core.models.workflow.WorkflowScript;
-import org.opencb.opencga.core.models.workflow.WorkflowVariable;
+import org.opencb.opencga.core.models.workflow.*;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
@@ -42,7 +40,7 @@
 @Tool(id = NextFlowExecutor.ID, resource = Enums.Resource.WORKFLOW, description = NextFlowExecutor.DESCRIPTION)
 public class NextFlowExecutor extends OpenCgaDockerToolScopeStudy {
 
-    public final static String ID = "workflow";
+    public final static String ID = "nextflow";
     public static final String DESCRIPTION = "Execute a Nextflow analysis.";
 
     @ToolParams
@@ -99,8 +97,12 @@ protected void check() throws Exception {
             }
         }
 
+        if (StringUtils.isEmpty(workflow.getManager().getVersion())) {
+            workflow.getManager().setVersion(ParamConstants.DEFAULT_MIN_NEXTFLOW_VERSION);
+        }
         // Update job tags and attributes
-        ToolInfoExecutor toolInfoExecutor = new ToolInfoExecutor(workflow.getManager().getId().name(), workflow.getManager().getVersion());
+        ToolInfoExecutor toolInfoExecutor = new ToolInfoExecutor(workflow.getManager().getId().name().toLowerCase(),
+                workflow.getManager().getVersion());
         Set<String> tags = new HashSet<>();
         tags.add(ID);
         tags.add(workflow.getManager().getId().name());
@@ -109,7 +111,7 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
-//        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
+        updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
 
         StringBuilder cliParamsBuilder = new StringBuilder();
         if (MapUtils.isNotEmpty(nextflowParams.getParams())) {
@@ -195,9 +197,9 @@ protected void run() throws Exception {
         String dockerImage = "opencb/opencga-workflow:TASK-6445";
         StringBuilder stringBuilder = new StringBuilder()
                 .append("bash -c \"NXF_VER=").append(workflow.getManager().getVersion()).append(" nextflow -c ").append(nextflowConfigPath).append(" run ");
-        if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getImage())) {
+        if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getId())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
-            stringBuilder.append(workflow.getRepository().getImage());
+            stringBuilder.append(workflow.getRepository().getId());
         } else {
             for (WorkflowScript script : workflow.getScripts()) {
                 if (script.isMain()) {
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
index a280339e86b..d741fb123ad 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
@@ -185,6 +185,7 @@ private RestResponse<Job> create() throws Exception {
             putNestedIfNotEmpty(beanParams, "id", commandOptions.id, true);
             putNestedIfNotEmpty(beanParams, "description", commandOptions.description, true);
             putNestedIfNotEmpty(beanParams, "tool.id", commandOptions.toolId, true);
+            putNestedIfNotEmpty(beanParams, "tool.version", commandOptions.toolVersion, true);
             putNestedIfNotEmpty(beanParams, "tool.description", commandOptions.toolDescription, true);
             putNestedIfNotNull(beanParams, "tool.scope", commandOptions.toolScope, true);
             putNestedIfNotNull(beanParams, "tool.type", commandOptions.toolType, true);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
index ae9004c3613..2e1e733a7d3 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
@@ -121,6 +121,9 @@ public class CreateCommandOptions {
         @Parameter(names = {"--tool-id"}, description = "Object ID is a mandatory parameter when creating a new one, this ID cannot be changed at the moment.", required = false, arity = 1)
         public String toolId;
     
+        @Parameter(names = {"--tool-version"}, description = "Version of the tool to be executed.", required = false, arity = 1)
+        public String toolVersion;
+    
         @Parameter(names = {"--tool-description"}, description = "Users may provide a description for the entry.", required = false, arity = 1)
         public String toolDescription;
     
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
index 30d7b212788..08e11bd5276 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
@@ -379,9 +379,9 @@ private void autoCompleteNewJob(String organizationId, Study study, Job job, Jwt
 
             job.setInput(Collections.emptyList());
         } else {
-            // We only check input files if the job does not depend on other job that might be creating the necessary file.
+            // We only check input files if the job does not depend on other job that might be creating the necessary files.
             List<File> inputFiles;
-            if (job.getTool().getId().equalsIgnoreCase("binary") || job.getTool().getId().equalsIgnoreCase("workflow")) {
+            if (job.getTool().getExternalExecutor() != null && StringUtils.isNotEmpty(job.getTool().getExternalExecutor().getId())) {
                 inputFiles = getWorkflowJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
             } else {
                 inputFiles = getJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
@@ -538,7 +538,7 @@ public OpenCGAResult<Job> retry(String studyStr, JobRetryParams jobRetry, Enums.
             if (StringUtils.isEmpty(jobDescription)) {
                 jobDescription = "Retry from job '" + jobRetry.getJob() + "'";
             }
-            return submit(studyStr, job.getTool().getId(), priority, params, jobId, jobDescription, jobDependsOn, jobTags, job.getId(),
+            return submit(studyStr, job.getTool(), priority, params, jobId, jobDescription, jobDependsOn, jobTags, job.getId(),
                     jobScheduledStartTime, job.isDryRun(), attributes, token);
         } else {
             throw new CatalogException("Unable to retry job with status " + job.getInternal().getStatus().getId());
@@ -571,11 +571,11 @@ public OpenCGAResult<Job> submitProject(String projectStr, String toolId, Enums.
     public OpenCGAResult<Job> submit(String studyStr, String toolId, Enums.Priority priority, Map<String, Object> params, String jobId,
                                      String jobDescription, List<String> jobDependsOn, List<String> jobTags, @Nullable String jobParentId,
                                      @Nullable String scheduledStartTime, Boolean dryRun, String token) throws CatalogException {
-        return submit(studyStr, toolId, priority, params, jobId, jobDescription, jobDependsOn, jobTags, jobParentId, scheduledStartTime,
-                dryRun, null, token);
+        return submit(studyStr, new ToolInfo().setId(toolId), priority, params, jobId, jobDescription, jobDependsOn, jobTags, jobParentId,
+                scheduledStartTime, dryRun, null, token);
     }
 
-    public OpenCGAResult<Job> submit(String studyStr, String toolId, Enums.Priority priority, Map<String, Object> params, String jobId,
+    public OpenCGAResult<Job> submit(String studyStr, ToolInfo toolInfo, Enums.Priority priority, Map<String, Object> params, String jobId,
                                      String jobDescription, List<String> jobDependsOn, List<String> jobTags,
                                      @Nullable String jobParentId, @Nullable String scheduledStartTime, Boolean dryRun,
                                      Map<String, Object> attributes, String token) throws CatalogException {
@@ -587,7 +587,7 @@ public OpenCGAResult<Job> submit(String studyStr, String toolId, Enums.Priority
 
         ObjectMap auditParams = new ObjectMap()
                 .append("study", studyStr)
-                .append("toolId", toolId)
+                .append("toolInfo", toolInfo)
                 .append("jobPriority", priority)
                 .append("params", params)
                 .append("jobId", jobId)
@@ -601,7 +601,7 @@ public OpenCGAResult<Job> submit(String studyStr, String toolId, Enums.Priority
         Job job = new Job();
         job.setId(jobId);
         job.setDescription(jobDescription);
-        job.setTool(new ToolInfo().setId(toolId));
+        job.setTool(toolInfo);
         job.setTags(jobTags);
         job.setStudy(new JobStudyParam(study.getFqn()));
         job.setUserId(userId);
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 5f41792868b..336fd202738 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -31,6 +31,9 @@
 import org.opencb.opencga.core.models.audit.AuditRecord;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.common.InternalStatus;
+import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.ToolInfo;
+import org.opencb.opencga.core.models.job.ToolInfoExecutor;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.models.study.StudyPermissions;
 import org.opencb.opencga.core.models.workflow.*;
@@ -39,6 +42,9 @@
 import org.slf4j.LoggerFactory;
 
 import javax.annotation.Nullable;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.URL;
 import java.util.*;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -50,7 +56,7 @@
 public class WorkflowManager extends ResourceManager<Workflow> {
 
     public static final QueryOptions INCLUDE_WORKFLOW_IDS = new QueryOptions(QueryOptions.INCLUDE, Arrays.asList(ID.key(), UID.key(),
-            UUID.key(), VERSION.key(), STUDY_UID.key()));
+            UUID.key(), VERSION.key(), DESCRIPTION.key(), STUDY_UID.key(), MANAGER.key()));
 
     private final CatalogIOManager catalogIOManager;
     private final IOManagerFactory ioManagerFactory;
@@ -167,6 +173,246 @@ public OpenCGAResult<Workflow> create(String studyStr, Workflow workflow, QueryO
         }
     }
 
+    public OpenCGAResult<Job> submit(String studyStr, NextFlowRunParams runParams, String jobId, String jobDescription,
+                                     String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority,
+                                     Boolean dryRun, String token) throws CatalogException {
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+
+        Study study = catalogManager.getStudyManager().resolveId(studyFqn, tokenPayload);
+        Query query = new Query();
+        if (runParams.getVersion() != null) {
+            query.append(VERSION.key(), runParams.getVersion());
+        }
+        Workflow workflow = internalGet(organizationId, study.getUid(), runParams.getId(), query, INCLUDE_WORKFLOW_IDS, userId).first();
+
+        ToolInfo toolInfo = new ToolInfo()
+                .setId(workflow.getId())
+                .setVersion(String.valueOf(workflow.getVersion()))
+                .setDescription(workflow.getDescription())
+                .setExternalExecutor(new ToolInfoExecutor(workflow.getManager().getId().name().toLowerCase(),
+                        workflow.getManager().getVersion()));
+
+        Map<String, Object> paramsMap = runParams.toParams();
+        paramsMap.putIfAbsent(ParamConstants.STUDY_PARAM, study.getFqn());
+
+        Enums.Priority priority = Enums.Priority.MEDIUM;
+        if (!StringUtils.isEmpty(jobPriority)) {
+            priority = Enums.Priority.getPriority(jobPriority.toUpperCase());
+        }
+
+        List<String> jobDependsOn;
+        if (StringUtils.isNotEmpty(jobDependsOnStr)) {
+            jobDependsOn = Arrays.asList(jobDependsOnStr.split(","));
+        } else {
+            jobDependsOn = Collections.emptyList();
+        }
+
+        List<String> jobTags;
+        if (StringUtils.isNotEmpty(jobTagsStr)) {
+            jobTags = Arrays.asList(jobTagsStr.split(","));
+        } else {
+            jobTags = Collections.emptyList();
+        }
+
+        return catalogManager.getJobManager().submit(study.getFqn(), toolInfo, priority, paramsMap, jobId, jobDescription, jobDependsOn,
+                jobTags, null, jobScheduledStartTime, dryRun, Collections.emptyMap(), token);
+    }
+
+    public OpenCGAResult<Workflow> importWorkflow(String studyStr, WorkflowRepositoryParams repository, QueryOptions options, String token)
+            throws CatalogException {
+        options = ParamUtils.defaultObject(options, QueryOptions::new);
+        JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
+        CatalogFqn studyFqn = CatalogFqn.extractFqnFromStudy(studyStr, tokenPayload);
+
+        ObjectMap auditParams = new ObjectMap()
+                .append("study", studyStr)
+                .append("repository", repository)
+                .append("options", options)
+                .append("token", token);
+
+        String organizationId = studyFqn.getOrganizationId();
+        String userId = tokenPayload.getUserId(organizationId);
+        String studyId = studyFqn.getStudyId();
+        String studyUuid = studyFqn.getStudyUuid();
+        String workflowId = "";
+        try {
+            Study study = catalogManager.getStudyManager().resolveId(studyFqn, StudyManager.INCLUDE_VARIABLE_SET, tokenPayload);
+            studyId = study.getId();
+            studyUuid = study.getUuid();
+
+            // 1. Check permissions
+            authorizationManager.checkStudyPermission(organizationId, study.getUid(), tokenPayload,
+                    StudyPermissions.Permissions.WRITE_WORKFLOWS);
+
+            // 2. Download workflow
+            Workflow workflow = downloadWorkflow(repository);
+            validateNewWorkflow(workflow, userId);
+            workflowId = workflow.getId();
+
+            OpenCGAResult<Workflow> result;
+
+            Query query = new Query()
+                    .append(STUDY_UID.key(), study.getUid())
+                    .append(ID.key(), workflow.getId());
+            OpenCGAResult<Workflow> tmpResult = getWorkflowDBAdaptor(organizationId).get(query, INCLUDE_WORKFLOW_IDS);
+            if (tmpResult.getNumResults() > 0) {
+                logger.warn("Workflow '" + workflowId + "' already exists. Updating with the latest workflow information.");
+                try {
+                    // Set workflow uid just in case users want to get the final result
+                    workflow.setUid(tmpResult.first().getUid());
+
+                    // Create update map removing the id to avoid the dbAdaptor exception
+                    ObjectMap updateMap = new ObjectMap(getUpdateObjectMapper().writeValueAsString(workflow));
+                    updateMap.remove("id");
+                    result = getWorkflowDBAdaptor(organizationId).update(tmpResult.first().getUid(), updateMap, QueryOptions.empty());
+                } catch (JsonProcessingException e) {
+                    throw new CatalogException("Internal error. Workflow '" + workflowId + "' already existed but it could not be updated",
+                            e);
+                }
+            } else {
+                // 3. We insert the workflow
+                result = getWorkflowDBAdaptor(organizationId).insert(study.getUid(), workflow, options);
+            }
+
+            if (options.getBoolean(ParamConstants.INCLUDE_RESULT_PARAM)) {
+                // Fetch created workflow
+                query = new Query()
+                        .append(STUDY_UID.key(), study.getUid())
+                        .append(UID.key(), workflow.getUid());
+                OpenCGAResult<Workflow> tmpTmpResult = getWorkflowDBAdaptor(organizationId).get(query, options);
+                result.setResults(tmpTmpResult.getResults());
+            }
+            auditManager.auditCreate(organizationId, userId, Enums.Resource.WORKFLOW, workflow.getId(), workflow.getUuid(), studyId,
+                    studyUuid, auditParams, new AuditRecord.Status(AuditRecord.Status.Result.SUCCESS));
+            return result;
+        } catch (CatalogException e) {
+            auditManager.auditCreate(organizationId, userId, Enums.Resource.WORKFLOW, workflowId, "", studyId, studyUuid, auditParams,
+                    new AuditRecord.Status(AuditRecord.Status.Result.ERROR, e.getError()));
+            throw e;
+        }
+    }
+
+    private Workflow downloadWorkflow(WorkflowRepositoryParams repository) throws CatalogException {
+        ParamUtils.checkObj(repository, "Workflow repository parameters");
+        if (StringUtils.isEmpty(repository.getId())) {
+            throw new CatalogParameterException("Missing 'id' field in workflow import parameters");
+        }
+        String workflowId = repository.getId().replace("/", ".");
+        String urlStr;
+
+        if (StringUtils.isEmpty(repository.getVersion())) {
+            urlStr = "https://raw.githubusercontent.com/" + repository.getId() + "/refs/heads/master/nextflow.config";
+        } else {
+            urlStr = "https://raw.githubusercontent.com/" + repository.getId() + "/refs/tags/" + repository.getVersion()
+                    + "/nextflow.config";
+        }
+
+        Workflow workflow = new Workflow("", "", "", null, new WorkflowSystem(WorkflowSystem.SystemId.NEXTFLOW, ""), new LinkedList<>(),
+                new LinkedList<>(), new WorkflowMinimumRequirements(), false, repository.toWorkflowRepository(), new LinkedList<>(),
+                new WorkflowInternal(), TimeUtils.getTime(), TimeUtils.getTime(), new HashMap<>());
+        try {
+            URL url = new URL(urlStr);
+            BufferedReader in = new BufferedReader(new InputStreamReader(url.openStream()));
+
+            // We add the bracket close strings because they are expected to be properly indented. That way, we will be able to know when
+            // that section has been properly closed. Otherwise, we may get confused by some other subsections that could be closed before
+            // the actual section closure.
+            String manifestBracketClose = null;
+            String profilesBracketClose = null;
+            String gitpodBracketClose = null;
+            String inputLine;
+            while ((inputLine = in.readLine()) != null) {
+                if (manifestBracketClose != null) {
+                    if (manifestBracketClose.equals(inputLine)) {
+                        manifestBracketClose = null;
+                    } else {
+                        // Process manifest line
+                        fillWithWorkflowManifest(workflow, inputLine);
+                    }
+                } else if (profilesBracketClose != null) {
+                    if (gitpodBracketClose != null) {
+                        if (gitpodBracketClose.equals(inputLine)) {
+                            gitpodBracketClose = null;
+                        } else {
+                            // Process gitpod line
+                            fillWithGitpodManifest(workflow, inputLine);
+                        }
+                    } else if (inputLine.trim().startsWith("gitpod {")) {
+                        int position = inputLine.indexOf("gitpod {");
+                        gitpodBracketClose = StringUtils.repeat(" ", position) + "}";
+                    } else if (profilesBracketClose.equals(inputLine)) {
+                        profilesBracketClose = null;
+                    }
+                } else if (inputLine.trim().startsWith("manifest {")) {
+                    int position = inputLine.indexOf("profiles {");
+                    manifestBracketClose = StringUtils.repeat(" ", position) + "}";
+                } else if (inputLine.trim().startsWith("profiles {")) {
+                    int position = inputLine.indexOf("profiles {");
+                    profilesBracketClose = StringUtils.repeat(" ", position) + "}";
+
+                }
+            }
+            in.close();
+        } catch (Exception e) {
+            throw new CatalogException("Could not import workflow '" + workflowId + "'.", e);
+        }
+
+        return workflow;
+    }
+
+    private void fillWithWorkflowManifest(Workflow workflow, String rawline) {
+        String[] split = rawline.split("= ");
+        String key = split[0].trim();
+//        String key = split[0].replaceAll(" ", "");
+        String value = split[1].replace("\"", "").replace("'", "").trim();
+        switch (key) {
+            case "name":
+                workflow.setId(value.replace("/", "."));
+                workflow.setName(value.replace("/", " "));
+                workflow.getRepository().setId(value);
+                break;
+            case "author":
+                workflow.getRepository().setAuthor(value);
+                break;
+            case "description":
+                workflow.setDescription(value);
+                workflow.getRepository().setDescription(value);
+                break;
+            case "version":
+                String version = value.replaceAll("^[^0-9]+|[^0-9.]+$", "");
+                workflow.getRepository().setVersion(version);
+                break;
+            case "nextflowVersion":
+                // Nextflow version must start with a number
+                version = value.replaceAll("^[^0-9]+|[^0-9.]+$", "");
+                workflow.getManager().setVersion(version);
+                break;
+            default:
+                break;
+        }
+    }
+
+    private void fillWithGitpodManifest(Workflow workflow, String rawline) {
+        String[] split = rawline.split("=");
+        String key = split[0].replaceAll(" ", "");
+        String value = split[1].replace("\"", "").replace("'", "").trim();
+        switch (key) {
+            case "executor.cpus":
+                workflow.getMinimumRequirements().setCpu(value);
+                break;
+            case "executor.memory":
+                workflow.getMinimumRequirements().setMemory(value.replace(".", ""));
+                break;
+            default:
+                break;
+        }
+    }
+
+
     public OpenCGAResult<Workflow> update(String studyStr, String workflowId, WorkflowUpdateParams updateParams, QueryOptions options,
                                           String token) throws CatalogException {
         options = ParamUtils.defaultObject(options, QueryOptions::new);
@@ -568,9 +814,6 @@ private void validateNewWorkflow(Workflow workflow, String userId) throws Catalo
         if (workflow.getManager().getId() == null) {
             workflow.getManager().setId(WorkflowSystem.SystemId.NEXTFLOW);
         }
-        if (StringUtils.isEmpty(workflow.getManager().getVersion())) {
-            workflow.getManager().setVersion("24.04.4");
-        }
         workflow.setType(ParamUtils.defaultObject(workflow.getType(), Workflow.Type.OTHER));
         workflow.setTags(workflow.getTags() != null ? workflow.getTags() : Collections.emptyList());
         workflow.setScripts(workflow.getScripts() != null ? workflow.getScripts() : Collections.emptyList());
@@ -589,10 +832,10 @@ private void validateNewWorkflow(Workflow workflow, String userId) throws Catalo
             throw new CatalogParameterException("No main script found.");
         }
         workflow.setRepository(workflow.getRepository() != null ? workflow.getRepository() : new WorkflowRepository(""));
-        if (StringUtils.isEmpty(workflow.getRepository().getImage()) && CollectionUtils.isEmpty(workflow.getScripts())) {
+        if (StringUtils.isEmpty(workflow.getRepository().getId()) && CollectionUtils.isEmpty(workflow.getScripts())) {
             throw new CatalogParameterException("No repository image or scripts found.");
         }
-        if (StringUtils.isNotEmpty(workflow.getRepository().getImage()) && CollectionUtils.isNotEmpty(workflow.getScripts())) {
+        if (StringUtils.isNotEmpty(workflow.getRepository().getId()) && CollectionUtils.isNotEmpty(workflow.getScripts())) {
             throw new CatalogParameterException("Both repository image and scripts found. Please, either add scripts or a repository"
                     + " image.");
         }
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/migration/MigrationManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/migration/MigrationManager.java
index aacf4949226..79b4050823b 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/migration/MigrationManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/migration/MigrationManager.java
@@ -21,6 +21,7 @@
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.managers.CatalogManager;
 import org.opencb.opencga.core.api.ParamConstants;
+import org.opencb.opencga.core.common.GitRepositoryState;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Configuration;
 import org.opencb.opencga.core.config.storage.StorageConfiguration;
@@ -744,7 +745,8 @@ private MigrationRun run(String organizationId, Class<? extends MigrationTool> r
                         .setCreationDate(TimeUtils.getTime(start))
                         .setCommandLine("opencga-admin.sh")
                         .setParams(params)
-                        .setTool(new ToolInfo(annotation.id(), annotation.description(), Tool.Scope.GLOBAL, null, null))
+                        .setTool(new ToolInfo(annotation.id(), GitRepositoryState.getInstance().getBuildVersion(), annotation.description(),
+                                Tool.Scope.GLOBAL, null, null))
                         .setOutDir(outdir.first())
                         .setStderr(stderr.first())
                         .setInternal(new JobInternal()
diff --git a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
index e88e3158d9a..f99a15e8a4f 100644
--- a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
+++ b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/WorkflowManagerTest.java
@@ -29,6 +29,24 @@ public void setUp() throws Exception {
         workflowManager = catalogManager.getWorkflowManager();
     }
 
+    @Test
+    public void importWorkflow() throws CatalogException {
+        WorkflowRepositoryParams params = new WorkflowRepositoryParams("nf-core/rnaseq");
+        OpenCGAResult<Workflow> result = workflowManager.importWorkflow(studyFqn, params, INCLUDE_RESULT, ownerToken);
+        assertEquals(1, result.getNumInserted());
+        assertEquals(1, result.first().getVersion());
+
+        // Update imported workflow
+        result = workflowManager.importWorkflow(studyFqn, params, INCLUDE_RESULT, ownerToken);
+        assertEquals(1, result.getNumUpdated());
+        assertEquals(2, result.first().getVersion());
+
+        params = new WorkflowRepositoryParams("nf-core/proteinfold");
+        result = workflowManager.importWorkflow(studyFqn, params, INCLUDE_RESULT, ownerToken);
+        assertEquals(1, result.getNumInserted());
+        assertEquals(1, result.first().getVersion());
+    }
+
     @Test
     public void createWorkflowTest() throws CatalogException {
         Workflow workflow = new Workflow()
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index 5e76aaa5ff3..859f37d8e61 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -300,6 +300,7 @@ public class FieldConstants {
 
 
     //ToolInfo
+    public static final String TOOL_INFO_VERSION_DESCRIPTION = "Version of the tool to be executed.";
     public static final String TOOL_INFO_SCOPE_DESCRIPTION = "Tool info scope can have the values GLOBAL, PROJECT and STUDY.";
     public static final String TOOL_INFO_TYPE_DESCRIPTION = "Tool info type can have the values OPERATION and ANALYSIS.";
     public static final String TOOL_INFO_RESOURCE_DESCRIPTION = "Tool info resource can have the values AUDIT, USER, PROJECT, "
@@ -325,6 +326,7 @@ public class FieldConstants {
     public static final String WORKFLOW_MIN_REQUIREMENTS_CPU_DESCRIPTION = "Minimum number of cpu cores required to execute the workflow.";
     public static final String WORKFLOW_MIN_REQUIREMENTS_MEMORY_DESCRIPTION = "Minimum memory required to execute the workflow"
             + " (expressed in GB).";
+    public static final String WORKFLOW_MIN_REQUIREMENTS_DISK_DESCRIPTION = "Minimum disk required to execute the workflow";
 
     public static final String WORKFLOW_SYSTEM_ID_DESCRIPTION = "Workflow system id. Valid values: NEXTFLOW.";
     public static final String WORKFLOW_SYSTEM_VERSION_DESCRIPTION = "Workflow system version to use.";
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
index ab4acd5e9a1..70def8cb18b 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/ParamConstants.java
@@ -79,6 +79,8 @@ public class ParamConstants {
     public static final String OVERWRITE = "overwrite";
     private static final String UP_TO_100 = " up to a maximum of 100";
 
+    public static final String DEFAULT_MIN_NEXTFLOW_VERSION = "24.04.4";
+
     public static final String CELLBASE_URL = "https://ws.zettagenomics.com/cellbase";
     public static final String CELLBASE_VERSION = "v5.8";
     public static final String CELLBASE_DATA_RELEASE_GRCH38 = "7";
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/config/Analysis.java b/opencga-core/src/main/java/org/opencb/opencga/core/config/Analysis.java
index 9f1c7b32683..166e41083c9 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/config/Analysis.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/config/Analysis.java
@@ -17,13 +17,12 @@
 package org.opencb.opencga.core.config;
 
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 public class Analysis {
 
     private List<String> packages;
+    private WorkflowConfiguration workflow;
 
     private String scratchDir;
     private String resourceUrl;
@@ -36,6 +35,7 @@ public class Analysis {
     private List<FrameworkConfiguration> frameworks;
 
     public Analysis() {
+        workflow = new WorkflowConfiguration();
         packages = new ArrayList<>();
         tools = new ArrayList<>();
         execution = new Execution();
@@ -51,6 +51,15 @@ public Analysis setPackages(List<String> packages) {
         return this;
     }
 
+    public WorkflowConfiguration getWorkflow() {
+        return workflow;
+    }
+
+    public Analysis setWorkflow(WorkflowConfiguration workflow) {
+        this.workflow = workflow;
+        return this;
+    }
+
     public String getScratchDir() {
         return scratchDir;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/config/Configuration.java b/opencga-core/src/main/java/org/opencb/opencga/core/config/Configuration.java
index b7b869c728c..95b7c3c4c6a 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/config/Configuration.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/config/Configuration.java
@@ -18,6 +18,10 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.opencb.opencga.core.api.ParamConstants;
+import org.opencb.opencga.core.models.workflow.WorkflowSystem;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -132,6 +136,30 @@ private static void addDefaultValueIfMissing(Configuration configuration) {
             // Disable password expiration by default
             configuration.getAccount().setPasswordExpirationDays(0);
         }
+        if (configuration.getAnalysis().getWorkflow() == null) {
+            configuration.getAnalysis().setWorkflow(new WorkflowConfiguration());
+        }
+        addDefaultAnalysisWorkflowValues(configuration.getAnalysis().getWorkflow());
+    }
+
+    private static void addDefaultAnalysisWorkflowValues(WorkflowConfiguration workflowConfiguration) {
+        if (CollectionUtils.isEmpty(workflowConfiguration.getManagers())) {
+            workflowConfiguration.setManagers(Collections.singletonList(
+                    new WorkflowSystemConfiguration(WorkflowSystem.SystemId.NEXTFLOW.name(), ParamConstants.DEFAULT_MIN_NEXTFLOW_VERSION)));
+        }
+        if (workflowConfiguration.getMinRequirements() == null) {
+            workflowConfiguration.setMinRequirements(new WorkflowMinRequirementsConfiguration());
+        }
+        WorkflowMinRequirementsConfiguration minRequirements = workflowConfiguration.getMinRequirements();
+        if (StringUtils.isEmpty(minRequirements.getCpu())) {
+            minRequirements.setCpu("2");
+        }
+        if (StringUtils.isEmpty(minRequirements.getMemory())) {
+            minRequirements.setMemory("8"); // GB
+        }
+        if (StringUtils.isEmpty(minRequirements.getDisk())) {
+            minRequirements.setDisk("100"); // GB
+        }
     }
 
     private static void overwriteWithEnvironmentVariables(Configuration configuration) {
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowConfiguration.java b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowConfiguration.java
new file mode 100644
index 00000000000..8f0b4cbabd6
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowConfiguration.java
@@ -0,0 +1,47 @@
+package org.opencb.opencga.core.config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class WorkflowConfiguration {
+
+    private WorkflowMinRequirementsConfiguration minRequirements;
+    private List<WorkflowSystemConfiguration> managers;
+
+    public WorkflowConfiguration() {
+        this.minRequirements = new WorkflowMinRequirementsConfiguration();
+        this.managers = new ArrayList<>();
+    }
+
+    public WorkflowConfiguration(WorkflowMinRequirementsConfiguration minRequirements, List<WorkflowSystemConfiguration> managers) {
+        this.minRequirements = minRequirements;
+        this.managers = managers;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowConfiguration{");
+        sb.append("minRequirements=").append(minRequirements);
+        sb.append(", managers=").append(managers);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public WorkflowMinRequirementsConfiguration getMinRequirements() {
+        return minRequirements;
+    }
+
+    public WorkflowConfiguration setMinRequirements(WorkflowMinRequirementsConfiguration minRequirements) {
+        this.minRequirements = minRequirements;
+        return this;
+    }
+
+    public List<WorkflowSystemConfiguration> getManagers() {
+        return managers;
+    }
+
+    public WorkflowConfiguration setManagers(List<WorkflowSystemConfiguration> managers) {
+        this.managers = managers;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowMinRequirementsConfiguration.java b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowMinRequirementsConfiguration.java
new file mode 100644
index 00000000000..4a886cd23f9
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowMinRequirementsConfiguration.java
@@ -0,0 +1,54 @@
+package org.opencb.opencga.core.config;
+
+public class WorkflowMinRequirementsConfiguration {
+
+    private String cpu;
+    private String memory;
+    private String disk;
+
+    public WorkflowMinRequirementsConfiguration() {
+    }
+
+    public WorkflowMinRequirementsConfiguration(String cpu, String memory, String disk) {
+        this.cpu = cpu;
+        this.memory = memory;
+        this.disk = disk;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowMinRequirementsConfiguration{");
+        sb.append("cpu='").append(cpu).append('\'');
+        sb.append(", memory='").append(memory).append('\'');
+        sb.append(", disk='").append(disk).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getCpu() {
+        return cpu;
+    }
+
+    public WorkflowMinRequirementsConfiguration setCpu(String cpu) {
+        this.cpu = cpu;
+        return this;
+    }
+
+    public String getMemory() {
+        return memory;
+    }
+
+    public WorkflowMinRequirementsConfiguration setMemory(String memory) {
+        this.memory = memory;
+        return this;
+    }
+
+    public String getDisk() {
+        return disk;
+    }
+
+    public WorkflowMinRequirementsConfiguration setDisk(String disk) {
+        this.disk = disk;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowSystemConfiguration.java b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowSystemConfiguration.java
new file mode 100644
index 00000000000..b3ac668d8e3
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowSystemConfiguration.java
@@ -0,0 +1,42 @@
+package org.opencb.opencga.core.config;
+
+public class WorkflowSystemConfiguration {
+
+    private String id;
+    private String version;
+
+    public WorkflowSystemConfiguration() {
+    }
+
+    public WorkflowSystemConfiguration(String id, String version) {
+        this.id = id;
+        this.version = version;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowSystemConfiguration{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", version='").append(version).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public WorkflowSystemConfiguration setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public WorkflowSystemConfiguration setVersion(String version) {
+        this.version = version;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
index 78c132dd18d..6026ca60132 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
@@ -29,6 +29,9 @@ public class ToolInfo {
             description = FieldConstants.GENERIC_ID_DESCRIPTION)
     private String id;
 
+    @DataField(id = "version", description = FieldConstants.TOOL_INFO_VERSION_DESCRIPTION)
+    private String version;
+
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
@@ -48,12 +51,14 @@ public class ToolInfo {
     public ToolInfo() {
     }
 
-    public ToolInfo(String id, String description, Scope scope, Type type, Enums.Resource resource) {
-        this(id, description, scope, type, resource, null);
+    public ToolInfo(String id, String version, String description, Scope scope, Type type, Enums.Resource resource) {
+        this(id, version, description, scope, type, resource, null);
     }
 
-    public ToolInfo(String id, String description, Scope scope, Type type, Enums.Resource resource, ToolInfoExecutor externalExecutor) {
+    public ToolInfo(String id, String version, String description, Scope scope, Type type, Enums.Resource resource,
+                    ToolInfoExecutor externalExecutor) {
         this.id = id;
+        this.version = version;
         this.description = description;
         this.scope = scope;
         this.type = type;
@@ -65,6 +70,7 @@ public ToolInfo(String id, String description, Scope scope, Type type, Enums.Res
     public String toString() {
         final StringBuilder sb = new StringBuilder("ToolInfo{");
         sb.append("id='").append(id).append('\'');
+        sb.append(", version='").append(version).append('\'');
         sb.append(", description='").append(description).append('\'');
         sb.append(", scope=").append(scope);
         sb.append(", type=").append(type);
@@ -83,6 +89,15 @@ public ToolInfo setId(String id) {
         return this;
     }
 
+    public String getVersion() {
+        return version;
+    }
+
+    public ToolInfo setVersion(String version) {
+        this.version = version;
+        return this;
+    }
+
     public String getDescription() {
         return description;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowImportParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowImportParams.java
new file mode 100644
index 00000000000..310e06998aa
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowImportParams.java
@@ -0,0 +1,42 @@
+package org.opencb.opencga.core.models.workflow;
+
+public class WorkflowImportParams {
+
+    private String source;
+    private String id;
+
+    public WorkflowImportParams() {
+    }
+
+    public WorkflowImportParams(String source, String id) {
+        this.source = source;
+        this.id = id;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowImportParams{");
+        sb.append("source='").append(source).append('\'');
+        sb.append(", id='").append(id).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getSource() {
+        return source;
+    }
+
+    public WorkflowImportParams setSource(String source) {
+        this.source = source;
+        return this;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public WorkflowImportParams setId(String id) {
+        this.id = id;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
index 4943ba13755..0f4a33b058b 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
@@ -6,43 +6,57 @@
 public class WorkflowMinimumRequirements {
 
     @DataField(id = "cpu", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_CPU_DESCRIPTION)
-    private Integer cpu;
+    private String cpu;
 
     @DataField(id = "memory", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_MEMORY_DESCRIPTION)
-    private Integer memory;
+    private String memory;
+
+    @DataField(id = "disk", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_DISK_DESCRIPTION)
+    private String disk;
 
     public WorkflowMinimumRequirements() {
     }
 
-    public WorkflowMinimumRequirements(int cpu, int memory) {
+    public WorkflowMinimumRequirements(String cpu, String memory, String disk) {
         this.cpu = cpu;
         this.memory = memory;
+        this.disk = disk;
     }
 
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("WorkflowMinimumRequirements{");
-        sb.append("cpu=").append(cpu);
-        sb.append(", memory=").append(memory);
+        sb.append("cpu='").append(cpu).append('\'');
+        sb.append(", memory='").append(memory).append('\'');
+        sb.append(", disk='").append(disk).append('\'');
         sb.append('}');
         return sb.toString();
     }
 
-    public int getCpu() {
+    public String getCpu() {
         return cpu;
     }
 
-    public WorkflowMinimumRequirements setCpu(int cpu) {
+    public WorkflowMinimumRequirements setCpu(String cpu) {
         this.cpu = cpu;
         return this;
     }
 
-    public int getMemory() {
+    public String getMemory() {
         return memory;
     }
 
-    public WorkflowMinimumRequirements setMemory(int memory) {
+    public WorkflowMinimumRequirements setMemory(String memory) {
         this.memory = memory;
         return this;
     }
+
+    public String getDisk() {
+        return disk;
+    }
+
+    public WorkflowMinimumRequirements setDisk(String disk) {
+        this.disk = disk;
+        return this;
+    }
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepository.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepository.java
index c2a86cbacb7..ebed05781f2 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepository.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepository.java
@@ -2,29 +2,69 @@
 
 public class WorkflowRepository {
 
-    private String image;
+    private String id;
+    private String version;
+    private String author;
+    private String description;
 
     public WorkflowRepository() {
     }
 
-    public WorkflowRepository(String image) {
-        this.image = image;
+    public WorkflowRepository(String id) {
+        this.id = id;
+    }
+
+    public WorkflowRepository(String id, String version, String author, String description) {
+        this.id = id;
+        this.version = version;
+        this.author = author;
+        this.description = description;
     }
 
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("WorkflowRepository{");
-        sb.append("image='").append(image).append('\'');
+        sb.append("id='").append(id).append('\'');
+        sb.append(", version='").append(version).append('\'');
+        sb.append(", author='").append(author).append('\'');
+        sb.append(", description='").append(description).append('\'');
         sb.append('}');
         return sb.toString();
     }
 
-    public String getImage() {
-        return image;
+    public String getId() {
+        return id;
+    }
+
+    public WorkflowRepository setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public WorkflowRepository setVersion(String version) {
+        this.version = version;
+        return this;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public WorkflowRepository setAuthor(String author) {
+        this.author = author;
+        return this;
+    }
+
+    public String getDescription() {
+        return description;
     }
 
-    public WorkflowRepository setImage(String image) {
-        this.image = image;
+    public WorkflowRepository setDescription(String description) {
+        this.description = description;
         return this;
     }
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepositoryParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepositoryParams.java
new file mode 100644
index 00000000000..275c712385d
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowRepositoryParams.java
@@ -0,0 +1,50 @@
+package org.opencb.opencga.core.models.workflow;
+
+public class WorkflowRepositoryParams {
+
+    private String id;
+    private String version;
+
+    public WorkflowRepositoryParams() {
+    }
+
+    public WorkflowRepositoryParams(String id) {
+        this.id = id;
+    }
+
+    public WorkflowRepositoryParams(String id, String version) {
+        this.id = id;
+        this.version = version;
+    }
+
+    public WorkflowRepository toWorkflowRepository() {
+        return new WorkflowRepository(id, version, "", "");
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowRepositoryParams{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", version='").append(version).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public WorkflowRepositoryParams setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public WorkflowRepositoryParams setVersion(String version) {
+        this.version = version;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/resources/configuration.yml b/opencga-core/src/main/resources/configuration.yml
index bb513b9df58..3cd38a58459 100644
--- a/opencga-core/src/main/resources/configuration.yml
+++ b/opencga-core/src/main/resources/configuration.yml
@@ -70,6 +70,16 @@ analysis:
   # List of packages where to find analysis tools
   packages:
     - "org.opencb.opencga"
+  workflow:
+    # Minimum requirements to run a workflow
+    minRequirements:
+      cpu: 2
+      memory: 8 # In GB
+      disk: 100 # In GB
+    # List of supported workflow managers and the version to be launched by default
+    managers:
+      - id: "NEXTFLOW"
+        version: "24.04.4"
   # Scratch folder for the analysis.
   scratchDir: "${OPENCGA.ANALYSIS.SCRATCH.DIR}"
   # Default URL for downloading analysis resources.
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
index 01c02bde4ad..5903164e493 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
@@ -88,6 +88,7 @@
 import org.opencb.opencga.catalog.utils.ParamUtils;
 import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.common.ExceptionUtils;
+import org.opencb.opencga.core.common.GitRepositoryState;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Execution;
 import org.opencb.opencga.core.config.storage.StorageConfiguration;
@@ -572,7 +573,8 @@ protected int checkPendingJob(Job job) {
         }
 
         PrivateJobUpdateParams updateParams = new PrivateJobUpdateParams();
-        updateParams.setTool(new ToolInfo(tool.id(), tool.description(), tool.scope(), tool.type(), tool.resource()));
+        updateParams.setTool(new ToolInfo(tool.id(), GitRepositoryState.getInstance().getBuildVersion(), tool.description(), tool.scope(),
+                tool.type(), tool.resource()));
 
         if (tool.scope() == Tool.Scope.PROJECT) {
             String projectFqn = job.getStudy().getId().substring(0, job.getStudy().getId().indexOf(ParamConstants.PROJECT_STUDY_SEPARATOR));
@@ -643,6 +645,10 @@ protected int checkPendingJob(Job job) {
         String shadedCommandLine = commandLine + " " + ParamConstants.OPENCGA_TOKEN_CLI_PARAM + " " + REDACTED_TOKEN;
 
         updateParams.setCommandLine(shadedCommandLine);
+        if (job.getTool().getExternalExecutor() == null || StringUtils.isEmpty(job.getTool().getExternalExecutor().getId())) {
+            job.getTool().setVersion(GitRepositoryState.getInstance().getBuildVersion());
+            updateParams.setTool(job.getTool());
+        }
 
         logger.info("Updating job {} from {} to {}", job.getId(), Enums.ExecutionStatus.PENDING, Enums.ExecutionStatus.QUEUED);
         updateParams.setInternal(new JobInternal(new Enums.ExecutionStatus(Enums.ExecutionStatus.QUEUED)));
@@ -844,7 +850,9 @@ private File getValidDefaultOutDir(String organizationId, Job job) throws Catalo
     }
 
     public static String buildCli(String internalCli, Job job) {
-        String toolId = job.getTool().getId();
+        String toolId = job.getTool().getExternalExecutor() != null && StringUtils.isNotEmpty(job.getTool().getExternalExecutor().getId())
+                ? job.getTool().getExternalExecutor().getId()
+                : job.getTool().getId();
         String internalCommand = TOOL_CLI_MAP.get(toolId);
         if (StringUtils.isEmpty(internalCommand) || job.isDryRun()) {
             ObjectMap params = new ObjectMap()
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
index 67a34804c84..2cce6b3ad8d 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
@@ -135,7 +135,10 @@ public Response runByPost(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = NextFlowRunParams.DESCRIPTION, required = true) JobRunParams params) {
-        return submitJob(CustomToolExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        ToolInfo toolInfo = new ToolInfo()
+                .setId("docker")
+                .setExternalExecutor(new ToolInfoExecutor(CustomToolExecutor.ID, ""));
+        return submitJob(toolInfo, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/OpenCGAWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/OpenCGAWSServer.java
index 3dae031c245..cdbe6329d78 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/OpenCGAWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/OpenCGAWSServer.java
@@ -47,6 +47,7 @@
 import org.opencb.opencga.core.models.JwtPayload;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.ToolInfo;
 import org.opencb.opencga.core.models.migration.MigrationRun;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.response.FederationNode;
@@ -873,6 +874,16 @@ public Response submitJobAdmin(String toolId, ToolParams bodyParams, String jobI
         });
     }
 
+    public Response submitJob(ToolInfo toolInfo, String study, ToolParams bodyParams, String jobId, String jobDescription,
+                              String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority, Boolean dryRun) {
+        return run(() -> submitJobRaw(toolInfo, null, study, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun));
+    }
+
+    public Response submitJob(ToolInfo toolInfo, String project, String study, ToolParams bodyParams, String jobId, String jobDescription,
+                              String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority, Boolean dryRun) {
+        return run(() -> submitJobRaw(toolInfo, project, study, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun));
+    }
+
     public Response submitJob(String toolId, String project, String study, ToolParams bodyParams, String jobId, String jobDescription,
                               String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority, Boolean dryRun) {
         return run(() -> submitJobRaw(toolId, project, study, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun));
@@ -931,6 +942,60 @@ protected DataResult<Job> submitJobRaw(String toolId, String project, String stu
                         jobScheduledStartTime, dryRun, token);
     }
 
+    protected DataResult<Job> submitJobRaw(ToolInfo toolInfo, String project, String study, ToolParams bodyParams, String jobId,
+                                           String jobDescription, String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime,
+                                           String jobPriority, Boolean dryRun)
+            throws CatalogException {
+        Map<String, Object> paramsMap = bodyParams.toParams();
+        if (StringUtils.isNotEmpty(study)) {
+            paramsMap.putIfAbsent(ParamConstants.STUDY_PARAM, study);
+        }
+        return submitJobRaw(toolInfo, project, study, paramsMap, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime,
+                jobPriority, dryRun);
+    }
+
+    protected DataResult<Job> submitJobRaw(ToolInfo toolInfo, String project, String study, Map<String, Object> paramsMap, String jobId,
+                                           String jobDescription, String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime,
+                                           String jobPriority, Boolean dryRun)
+            throws CatalogException {
+
+        if (StringUtils.isNotEmpty(project) && StringUtils.isEmpty(study)) {
+            // Project job
+            QueryOptions options = new QueryOptions(QueryOptions.INCLUDE, StudyDBAdaptor.QueryParams.FQN.key());
+            // Peek any study. The ExecutionDaemon will take care of filling up the rest of studies.
+            List<String> studies = catalogManager.getStudyManager()
+                    .search(project, new Query(), options, token)
+                    .getResults()
+                    .stream()
+                    .map(Study::getFqn)
+                    .collect(Collectors.toList());
+            if (studies.isEmpty()) {
+                throw new CatalogException("Project '" + project + "' not found!");
+            }
+            study = studies.get(0);
+        }
+
+        List<String> jobTags;
+        if (StringUtils.isNotEmpty(jobTagsStr)) {
+            jobTags = Arrays.asList(jobTagsStr.split(","));
+        } else {
+            jobTags = Collections.emptyList();
+        }
+        List<String> jobDependsOn;
+        if (StringUtils.isNotEmpty(jobDependsOnStr)) {
+            jobDependsOn = Arrays.asList(jobDependsOnStr.split(","));
+        } else {
+            jobDependsOn = Collections.emptyList();
+        }
+        Enums.Priority priority = Enums.Priority.MEDIUM;
+        if (!StringUtils.isEmpty(jobPriority)) {
+            priority = Enums.Priority.getPriority(jobPriority.toUpperCase());
+        }
+        return catalogManager.getJobManager()
+                .submit(study, toolInfo, priority, paramsMap, jobId, jobDescription, jobDependsOn, jobTags, null,
+                        jobScheduledStartTime, dryRun, Collections.emptyMap(), token);
+    }
+
     public Response createPendingResponse() {
         return createErrorResponse(new NotImplementedException("Pending " + uriInfo.getPath()));
     }
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
index 6c766b87d44..fff022ed1ee 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
@@ -97,7 +97,8 @@ public Response updateByPost(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = NextFlowRunParams.DESCRIPTION, required = true) NextFlowRunParams params) {
-        return submitJob(NextFlowExecutor.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return run(() -> catalogManager.getWorkflowManager().submit(study, params, jobName, jobDescription, dependsOn, jobTags,
+                scheduledStartTime, jobPriority, dryRun, token));
     }
 
     @GET

From 52a0de73d08caffac6ef50b87e2ba90fedd2a1ba Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 22 Oct 2024 16:42:57 +0200
Subject: [PATCH 87/99] server: add import web service, #TASK-6445

---
 .../opencga/catalog/managers/WorkflowManager.java      |  2 +-
 .../opencb/opencga/server/rest/WorkflowWSServer.java   | 10 ++++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 336fd202738..d6d5c2c6110 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -240,7 +240,7 @@ public OpenCGAResult<Workflow> importWorkflow(String studyStr, WorkflowRepositor
         String studyUuid = studyFqn.getStudyUuid();
         String workflowId = "";
         try {
-            Study study = catalogManager.getStudyManager().resolveId(studyFqn, StudyManager.INCLUDE_VARIABLE_SET, tokenPayload);
+            Study study = catalogManager.getStudyManager().resolveId(studyFqn, tokenPayload);
             studyId = study.getId();
             studyUuid = study.getUuid();
 
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
index fff022ed1ee..adf2a4ed3af 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/WorkflowWSServer.java
@@ -101,6 +101,16 @@ public Response updateByPost(
                 scheduledStartTime, jobPriority, dryRun, token));
     }
 
+    @POST
+    @Path("/import")
+    @Consumes(MediaType.APPLICATION_JSON)
+    @ApiOperation(value = NextFlowExecutor.DESCRIPTION, response = Job.class)
+    public Response importWorkflow(
+            @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String study,
+            @ApiParam(value = "Repository parameters", required = true) WorkflowRepositoryParams params) {
+        return run(() -> catalogManager.getWorkflowManager().importWorkflow(study, params, queryOptions, token));
+    }
+
     @GET
     @Path("/search")
     @ApiOperation(value = "Workflow search method", response = Workflow.class)

From 6cc846bc37c914b1837d4c981f94092314dc373e Mon Sep 17 00:00:00 2001
From: imedina <igmecas@gmail.com>
Date: Wed, 23 Oct 2024 00:52:12 +0100
Subject: [PATCH 88/99] client: add workflow clients and CLI

---
 .../app/misc/clients/rest_client_generator.py |   6 +-
 .../app/cli/main/OpenCgaCompleter.java        |   8 +-
 .../app/cli/main/OpencgaCliOptionsParser.java |  20 +
 .../executors/WorkflowsCommandExecutor.java   | 418 +++++++++++++++
 .../main/options/WorkflowsCommandOptions.java | 499 ++++++++++++++++++
 .../src/main/R/R/Workflow-methods.R           |   8 +
 .../opencga/client/rest/OpenCGAClient.java    |  37 +-
 .../client/rest/clients/WorkflowClient.java   |  15 +
 .../src/main/javascript/Workflow.js           |  10 +
 .../pyopencga/rest_clients/workflow_client.py |  12 +
 .../src/main/resources/cli-config.yaml        |   8 +
 11 files changed, 1019 insertions(+), 22 deletions(-)
 create mode 100644 opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
 create mode 100644 opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java

diff --git a/opencga-app/app/misc/clients/rest_client_generator.py b/opencga-app/app/misc/clients/rest_client_generator.py
index 5863dc717ac..901e1d9449b 100644
--- a/opencga-app/app/misc/clients/rest_client_generator.py
+++ b/opencga-app/app/misc/clients/rest_client_generator.py
@@ -32,7 +32,8 @@ def __init__(self, rest_api_file, output_dir):
                 'method_name': 'update_interpretation'},
             'analysis/clinical/{clinicalAnalysis}/interpretation/{interpretations}/delete': {
                 'method_name': 'delete_interpretation'},
-            'panels/import': {'method_name': 'import_panels'}
+            'panels/import': {'method_name': 'import_panels'},
+            'workflows/import': {'method_name': 'import_workflow'}
         }
         self.categories = {
             'Organizations': 'Organization',
@@ -41,12 +42,13 @@ def __init__(self, rest_api_file, output_dir):
             'Studies': 'Study',
             'Files': 'File',
             'Jobs': 'Job',
-            'Workflows': 'Workflow',
             'Samples': 'Sample',
             'Individuals': 'Individual',
             'Families': 'Family',
             'Cohorts': 'Cohort',
             'Disease Panels': 'DiseasePanel',
+            'Notes': 'Note',
+            'Workflows': 'Workflow',
             'Analysis - Alignment': 'Alignment',
             'Analysis - Variant': 'Variant',
             'Analysis - Clinical': 'ClinicalAnalysis',
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
index 62caa974cb5..c56cf37ed81 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpenCgaCompleter.java
@@ -24,7 +24,7 @@
 
 public abstract class OpenCgaCompleter implements Completer {
 
-    protected List<Candidate> commands = asList("login","logout","help","use","variant","projects","panels","clinical","jobs","admin","individuals","families","users","samples","alignments","meta","organizations","studies","files","operations","cohorts")
+    protected List<Candidate> commands = asList("login","logout","help","use","variant","projects","panels","clinical","jobs","admin","workflows","individuals","families","users","samples","alignments","meta","organizations","studies","files","operations","cohorts")
             .stream()
             .map(Candidate::new)
             .collect(toList());
@@ -59,6 +59,11 @@ public abstract class OpenCgaCompleter implements Completer {
             .map(Candidate::new)
             .collect(toList());
 
+    private List<Candidate> workflowsList = asList( "acl-update","create","distinct","import","run","search","update","acl","delete","info")
+            .stream()
+            .map(Candidate::new)
+            .collect(toList());
+
     private List<Candidate> individualsList = asList( "acl-update","annotation-sets-load","create","distinct","search","acl","delete","info","update","annotation-sets-annotations-update","relatives")
             .stream()
             .map(Candidate::new)
@@ -128,6 +133,7 @@ public void complete(LineReader lineReader, ParsedLine parsedLine, List<Candidat
         mapCandidates.put( "clinical", clinicalList);
         mapCandidates.put( "jobs", jobsList);
         mapCandidates.put( "admin", adminList);
+        mapCandidates.put( "workflows", workflowsList);
         mapCandidates.put( "individuals", individualsList);
         mapCandidates.put( "families", familiesList);
         mapCandidates.put( "users", usersList);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
index e376e4e6cee..a43f79f22dc 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/OpencgaCliOptionsParser.java
@@ -24,6 +24,7 @@ public class OpencgaCliOptionsParser extends CustomCliOptionsParser {
     private final AnalysisClinicalCommandOptions analysisClinicalCommandOptions;
     private final JobsCommandOptions jobsCommandOptions;
     private final AdminCommandOptions adminCommandOptions;
+    private final WorkflowsCommandOptions workflowsCommandOptions;
     private final IndividualsCommandOptions individualsCommandOptions;
     private final FamiliesCommandOptions familiesCommandOptions;
     private final UsersCommandOptions usersCommandOptions;
@@ -181,6 +182,20 @@ public OpencgaCliOptionsParser() {
         adminSubCommands.addCommand("users-sync", adminCommandOptions.syncUsersCommandOptions);
         adminSubCommands.addCommand("update-groups-users", adminCommandOptions.usersUpdateGroupsCommandOptions);
 
+        workflowsCommandOptions = new WorkflowsCommandOptions(commonCommandOptions, jCommander);
+        jCommander.addCommand("workflows", workflowsCommandOptions);
+        JCommander workflowsSubCommands = jCommander.getCommands().get("workflows");
+        workflowsSubCommands.addCommand("acl-update", workflowsCommandOptions.updateAclCommandOptions);
+        workflowsSubCommands.addCommand("create", workflowsCommandOptions.createCommandOptions);
+        workflowsSubCommands.addCommand("distinct", workflowsCommandOptions.distinctCommandOptions);
+        workflowsSubCommands.addCommand("import", workflowsCommandOptions.importCommandOptions);
+        workflowsSubCommands.addCommand("run", workflowsCommandOptions.runCommandOptions);
+        workflowsSubCommands.addCommand("search", workflowsCommandOptions.searchCommandOptions);
+        workflowsSubCommands.addCommand("update", workflowsCommandOptions.updateCommandOptions);
+        workflowsSubCommands.addCommand("acl", workflowsCommandOptions.aclCommandOptions);
+        workflowsSubCommands.addCommand("delete", workflowsCommandOptions.deleteCommandOptions);
+        workflowsSubCommands.addCommand("info", workflowsCommandOptions.infoCommandOptions);
+
         individualsCommandOptions = new IndividualsCommandOptions(commonCommandOptions, jCommander);
         jCommander.addCommand("individuals", individualsCommandOptions);
         JCommander individualsSubCommands = jCommander.getCommands().get("individuals");
@@ -418,6 +433,11 @@ public AdminCommandOptions getAdminCommandOptions() {
     }
     
     
+    public WorkflowsCommandOptions getWorkflowsCommandOptions() {
+        return workflowsCommandOptions;
+    }
+    
+    
     public IndividualsCommandOptions getIndividualsCommandOptions() {
         return individualsCommandOptions;
     }
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
new file mode 100644
index 00000000000..f910b4f80be
--- /dev/null
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
@@ -0,0 +1,418 @@
+package org.opencb.opencga.app.cli.main.executors;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import java.util.HashMap;
+import java.util.List;
+import org.opencb.commons.datastore.core.ObjectMap;
+import org.opencb.commons.utils.PrintUtils;
+import org.opencb.opencga.app.cli.main.*;
+import org.opencb.opencga.app.cli.main.executors.OpencgaCommandExecutor;
+import org.opencb.opencga.app.cli.main.options.WorkflowsCommandOptions;
+import org.opencb.opencga.catalog.exceptions.CatalogAuthenticationException;
+import org.opencb.opencga.catalog.utils.ParamUtils.AclAction;
+import org.opencb.opencga.client.exceptions.ClientException;
+import org.opencb.opencga.core.common.JacksonUtils;
+import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
+import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
+import org.opencb.opencga.core.models.workflow.WorkflowAclUpdateParams;
+import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
+import org.opencb.opencga.core.models.workflow.WorkflowMinimumRequirements;
+import org.opencb.opencga.core.models.workflow.WorkflowRepository;
+import org.opencb.opencga.core.models.workflow.WorkflowRepositoryParams;
+import org.opencb.opencga.core.models.workflow.WorkflowSystem;
+import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
+import org.opencb.opencga.core.response.QueryType;
+import org.opencb.opencga.core.response.RestResponse;
+
+
+/*
+* WARNING: AUTOGENERATED CODE
+*
+* This code was generated by a tool.
+*
+* Manual changes to this file may cause unexpected behavior in your application.
+* Manual changes to this file will be overwritten if the code is regenerated.
+*  
+*/
+/**
+ * This class contains methods for the Workflows command line.
+ *    PATH: /{apiVersion}/workflows
+ */
+public class WorkflowsCommandExecutor extends OpencgaCommandExecutor {
+
+    public String categoryName = "workflows";
+    public WorkflowsCommandOptions workflowsCommandOptions;
+
+    public WorkflowsCommandExecutor(WorkflowsCommandOptions workflowsCommandOptions) throws CatalogAuthenticationException {
+        super(workflowsCommandOptions.commonCommandOptions);
+        this.workflowsCommandOptions = workflowsCommandOptions;
+    }
+
+    @Override
+    public void execute() throws Exception {
+
+        logger.debug("Executing Workflows command line");
+
+        String subCommandString = getParsedSubCommand(workflowsCommandOptions.jCommander);
+
+        RestResponse queryResponse = null;
+
+        switch (subCommandString) {
+            case "acl-update":
+                queryResponse = updateAcl();
+                break;
+            case "create":
+                queryResponse = create();
+                break;
+            case "distinct":
+                queryResponse = distinct();
+                break;
+            case "import":
+                queryResponse = importWorkflow();
+                break;
+            case "run":
+                queryResponse = run();
+                break;
+            case "search":
+                queryResponse = search();
+                break;
+            case "update":
+                queryResponse = update();
+                break;
+            case "acl":
+                queryResponse = acl();
+                break;
+            case "delete":
+                queryResponse = delete();
+                break;
+            case "info":
+                queryResponse = info();
+                break;
+            default:
+                logger.error("Subcommand not valid");
+                break;
+        }
+
+        createOutput(queryResponse);
+
+    }
+
+    private RestResponse<WorkflowAclEntryList> updateAcl() throws Exception {
+        logger.debug("Executing updateAcl in Workflows command line");
+
+        WorkflowsCommandOptions.UpdateAclCommandOptions commandOptions = workflowsCommandOptions.updateAclCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        WorkflowAclUpdateParams workflowAclUpdateParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<WorkflowAclEntryList> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/workflows/acl/{members}/update"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            workflowAclUpdateParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), WorkflowAclUpdateParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotNull(beanParams, "workflowIds", commandOptions.workflowIds, true);
+            putNestedIfNotNull(beanParams, "permissions", commandOptions.permissions, true);
+
+            workflowAclUpdateParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), WorkflowAclUpdateParams.class);
+        }
+        return openCGAClient.getWorkflowClient().updateAcl(commandOptions.members, commandOptions.action, workflowAclUpdateParams, queryParams);
+    }
+
+    private RestResponse<Workflow> create() throws Exception {
+        logger.debug("Executing create in Workflows command line");
+
+        WorkflowsCommandOptions.CreateCommandOptions commandOptions = workflowsCommandOptions.createCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("include", commandOptions.include);
+        queryParams.putIfNotEmpty("exclude", commandOptions.exclude);
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotNull("includeResult", commandOptions.includeResult);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        WorkflowCreateParams workflowCreateParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<Workflow> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/workflows/create"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            workflowCreateParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), WorkflowCreateParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotEmpty(beanParams, "id", commandOptions.id, true);
+            putNestedIfNotEmpty(beanParams, "name", commandOptions.name, true);
+            putNestedIfNotEmpty(beanParams, "description", commandOptions.description, true);
+            putNestedIfNotNull(beanParams, "manager.id", commandOptions.managerId, true);
+            putNestedIfNotEmpty(beanParams, "manager.version", commandOptions.managerVersion, true);
+            putNestedIfNotNull(beanParams, "type", commandOptions.type, true);
+            putNestedIfNotNull(beanParams, "tags", commandOptions.tags, true);
+            putNestedIfNotNull(beanParams, "draft", commandOptions.draft, true);
+            putNestedIfNotEmpty(beanParams, "repository.id", commandOptions.repositoryId, true);
+            putNestedIfNotEmpty(beanParams, "repository.version", commandOptions.repositoryVersion, true);
+            putNestedIfNotEmpty(beanParams, "repository.author", commandOptions.repositoryAuthor, true);
+            putNestedIfNotEmpty(beanParams, "repository.description", commandOptions.repositoryDescription, true);
+            putNestedIfNotEmpty(beanParams, "minimumRequirements.cpu", commandOptions.minimumRequirementsCpu, true);
+            putNestedIfNotEmpty(beanParams, "minimumRequirements.memory", commandOptions.minimumRequirementsMemory, true);
+            putNestedIfNotEmpty(beanParams, "minimumRequirements.disk", commandOptions.minimumRequirementsDisk, true);
+            putNestedIfNotEmpty(beanParams, "creationDate", commandOptions.creationDate, true);
+            putNestedIfNotEmpty(beanParams, "modificationDate", commandOptions.modificationDate, true);
+            putNestedMapIfNotEmpty(beanParams, "attributes", commandOptions.attributes, true);
+
+            workflowCreateParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), WorkflowCreateParams.class);
+        }
+        return openCGAClient.getWorkflowClient().create(workflowCreateParams, queryParams);
+    }
+
+    private RestResponse<Object> distinct() throws Exception {
+        logger.debug("Executing distinct in Workflows command line");
+
+        WorkflowsCommandOptions.DistinctCommandOptions commandOptions = workflowsCommandOptions.distinctCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("id", commandOptions.id);
+        queryParams.putIfNotEmpty("name", commandOptions.name);
+        queryParams.putIfNotEmpty("uuid", commandOptions.uuid);
+        queryParams.putIfNotEmpty("tags", commandOptions.tags);
+        queryParams.putIfNotNull("draft", commandOptions.draft);
+        queryParams.putIfNotEmpty("internalRegistrationUserId", commandOptions.internalRegistrationUserId);
+        queryParams.putIfNotEmpty("managerId", commandOptions.managerId);
+        queryParams.putIfNotEmpty("type", commandOptions.type);
+        queryParams.putIfNotEmpty("creationDate", commandOptions.creationDate);
+        queryParams.putIfNotEmpty("modificationDate", commandOptions.modificationDate);
+        queryParams.putIfNotEmpty("acl", commandOptions.acl);
+        queryParams.putIfNotEmpty("release", commandOptions.release);
+        queryParams.putIfNotNull("snapshot", commandOptions.snapshot);
+        queryParams.putIfNotNull("deleted", commandOptions.deleted);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+        return openCGAClient.getWorkflowClient().distinct(commandOptions.field, queryParams);
+    }
+
+    private RestResponse<Job> importWorkflow() throws Exception {
+        logger.debug("Executing importWorkflow in Workflows command line");
+
+        WorkflowsCommandOptions.ImportCommandOptions commandOptions = workflowsCommandOptions.importCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        WorkflowRepositoryParams workflowRepositoryParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<Job> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/workflows/import"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            workflowRepositoryParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), WorkflowRepositoryParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotEmpty(beanParams, "id", commandOptions.id, true);
+            putNestedIfNotEmpty(beanParams, "version", commandOptions.version, true);
+
+            workflowRepositoryParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), WorkflowRepositoryParams.class);
+        }
+        return openCGAClient.getWorkflowClient().importWorkflow(workflowRepositoryParams, queryParams);
+    }
+
+    private RestResponse<Job> run() throws Exception {
+        logger.debug("Executing run in Workflows command line");
+
+        WorkflowsCommandOptions.RunCommandOptions commandOptions = workflowsCommandOptions.runCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("jobId", commandOptions.jobId);
+        queryParams.putIfNotEmpty("jobDescription", commandOptions.jobDescription);
+        queryParams.putIfNotEmpty("jobDependsOn", commandOptions.jobDependsOn);
+        queryParams.putIfNotEmpty("jobTags", commandOptions.jobTags);
+        queryParams.putIfNotEmpty("jobScheduledStartTime", commandOptions.jobScheduledStartTime);
+        queryParams.putIfNotEmpty("jobPriority", commandOptions.jobPriority);
+        queryParams.putIfNotNull("jobDryRun", commandOptions.jobDryRun);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        NextFlowRunParams nextFlowRunParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<Job> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/workflows/run"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            nextFlowRunParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), NextFlowRunParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotEmpty(beanParams, "id", commandOptions.id, true);
+            putNestedIfNotNull(beanParams, "version", commandOptions.version, true);
+            putNestedMapIfNotEmpty(beanParams, "params", commandOptions.params, true);
+
+            nextFlowRunParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), NextFlowRunParams.class);
+        }
+        return openCGAClient.getWorkflowClient().run(nextFlowRunParams, queryParams);
+    }
+
+    private RestResponse<Workflow> search() throws Exception {
+        logger.debug("Executing search in Workflows command line");
+
+        WorkflowsCommandOptions.SearchCommandOptions commandOptions = workflowsCommandOptions.searchCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("include", commandOptions.include);
+        queryParams.putIfNotEmpty("exclude", commandOptions.exclude);
+        queryParams.putIfNotNull("limit", commandOptions.limit);
+        queryParams.putIfNotNull("skip", commandOptions.skip);
+        queryParams.putIfNotNull("count", commandOptions.count);
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("id", commandOptions.id);
+        queryParams.putIfNotEmpty("name", commandOptions.name);
+        queryParams.putIfNotEmpty("uuid", commandOptions.uuid);
+        queryParams.putIfNotEmpty("tags", commandOptions.tags);
+        queryParams.putIfNotNull("draft", commandOptions.draft);
+        queryParams.putIfNotEmpty("internalRegistrationUserId", commandOptions.internalRegistrationUserId);
+        queryParams.putIfNotEmpty("managerId", commandOptions.managerId);
+        queryParams.putIfNotEmpty("type", commandOptions.type);
+        queryParams.putIfNotEmpty("creationDate", commandOptions.creationDate);
+        queryParams.putIfNotEmpty("modificationDate", commandOptions.modificationDate);
+        queryParams.putIfNotEmpty("acl", commandOptions.acl);
+        queryParams.putIfNotEmpty("release", commandOptions.release);
+        queryParams.putIfNotNull("snapshot", commandOptions.snapshot);
+        queryParams.putIfNotNull("deleted", commandOptions.deleted);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+        return openCGAClient.getWorkflowClient().search(queryParams);
+    }
+
+    private RestResponse<Workflow> update() throws Exception {
+        logger.debug("Executing update in Workflows command line");
+
+        WorkflowsCommandOptions.UpdateCommandOptions commandOptions = workflowsCommandOptions.updateCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("include", commandOptions.include);
+        queryParams.putIfNotEmpty("exclude", commandOptions.exclude);
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotNull("includeResult", commandOptions.includeResult);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+
+        WorkflowUpdateParams workflowUpdateParams = null;
+        if (commandOptions.jsonDataModel) {
+            RestResponse<Workflow> res = new RestResponse<>();
+            res.setType(QueryType.VOID);
+            PrintUtils.println(getObjectAsJSON(categoryName,"/{apiVersion}/workflows/{workflowId}/update"));
+            return res;
+        } else if (commandOptions.jsonFile != null) {
+            workflowUpdateParams = JacksonUtils.getDefaultObjectMapper()
+                    .readValue(new java.io.File(commandOptions.jsonFile), WorkflowUpdateParams.class);
+        } else {
+            ObjectMap beanParams = new ObjectMap();
+            putNestedIfNotEmpty(beanParams, "name", commandOptions.name, true);
+            putNestedIfNotEmpty(beanParams, "description", commandOptions.description, true);
+            putNestedIfNotNull(beanParams, "manager.id", commandOptions.managerId, true);
+            putNestedIfNotEmpty(beanParams, "manager.version", commandOptions.managerVersion, true);
+            putNestedIfNotNull(beanParams, "type", commandOptions.type, true);
+            putNestedIfNotNull(beanParams, "tags", commandOptions.tags, true);
+            putNestedIfNotNull(beanParams, "draft", commandOptions.draft, true);
+            putNestedIfNotEmpty(beanParams, "repository.id", commandOptions.repositoryId, true);
+            putNestedIfNotEmpty(beanParams, "repository.version", commandOptions.repositoryVersion, true);
+            putNestedIfNotEmpty(beanParams, "repository.author", commandOptions.repositoryAuthor, true);
+            putNestedIfNotEmpty(beanParams, "repository.description", commandOptions.repositoryDescription, true);
+            putNestedIfNotEmpty(beanParams, "creationDate", commandOptions.creationDate, true);
+            putNestedIfNotEmpty(beanParams, "modificationDate", commandOptions.modificationDate, true);
+            putNestedMapIfNotEmpty(beanParams, "attributes", commandOptions.attributes, true);
+
+            workflowUpdateParams = JacksonUtils.getDefaultObjectMapper().copy()
+                    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true)
+                    .readValue(beanParams.toJson(), WorkflowUpdateParams.class);
+        }
+        return openCGAClient.getWorkflowClient().update(commandOptions.workflowId, workflowUpdateParams, queryParams);
+    }
+
+    private RestResponse<WorkflowAclEntryList> acl() throws Exception {
+        logger.debug("Executing acl in Workflows command line");
+
+        WorkflowsCommandOptions.AclCommandOptions commandOptions = workflowsCommandOptions.aclCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("member", commandOptions.member);
+        queryParams.putIfNotNull("silent", commandOptions.silent);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+        return openCGAClient.getWorkflowClient().acl(commandOptions.workflows, queryParams);
+    }
+
+    private RestResponse<Workflow> delete() throws Exception {
+        logger.debug("Executing delete in Workflows command line");
+
+        WorkflowsCommandOptions.DeleteCommandOptions commandOptions = workflowsCommandOptions.deleteCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+        return openCGAClient.getWorkflowClient().delete(commandOptions.workflows, queryParams);
+    }
+
+    private RestResponse<Workflow> info() throws Exception {
+        logger.debug("Executing info in Workflows command line");
+
+        WorkflowsCommandOptions.InfoCommandOptions commandOptions = workflowsCommandOptions.infoCommandOptions;
+
+        ObjectMap queryParams = new ObjectMap();
+        queryParams.putIfNotEmpty("include", commandOptions.include);
+        queryParams.putIfNotEmpty("exclude", commandOptions.exclude);
+        queryParams.putIfNotEmpty("study", commandOptions.study);
+        queryParams.putIfNotEmpty("version", commandOptions.version);
+        queryParams.putIfNotNull("deleted", commandOptions.deleted);
+        if (queryParams.get("study") == null && OpencgaMain.isShellMode()) {
+            queryParams.putIfNotEmpty("study", sessionManager.getSession().getCurrentStudy());
+        }
+
+        return openCGAClient.getWorkflowClient().info(commandOptions.workflows, queryParams);
+    }
+}
\ No newline at end of file
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java
new file mode 100644
index 00000000000..c395b9c8d62
--- /dev/null
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java
@@ -0,0 +1,499 @@
+package org.opencb.opencga.app.cli.main.options;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.Parameters;
+import com.beust.jcommander.DynamicParameter;
+import com.beust.jcommander.ParametersDelegate;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.List;
+
+import static org.opencb.opencga.app.cli.GeneralCliOptions.*;
+
+
+/*
+* WARNING: AUTOGENERATED CODE
+*
+* This code was generated by a tool.
+*
+* Manual changes to this file may cause unexpected behavior in your application.
+* Manual changes to this file will be overwritten if the code is regenerated.
+*  
+*/
+
+/**
+ * This class contains methods for the Workflows command line.
+ *    PATH: /{apiVersion}/workflows
+ */
+@Parameters(commandNames = {"workflows"}, commandDescription = "Workflows commands")
+public class WorkflowsCommandOptions {
+
+        public JCommander jCommander;
+        public CommonCommandOptions commonCommandOptions;
+
+        public UpdateAclCommandOptions updateAclCommandOptions;
+        public CreateCommandOptions createCommandOptions;
+        public DistinctCommandOptions distinctCommandOptions;
+        public ImportCommandOptions importCommandOptions;
+        public RunCommandOptions runCommandOptions;
+        public SearchCommandOptions searchCommandOptions;
+        public UpdateCommandOptions updateCommandOptions;
+        public AclCommandOptions aclCommandOptions;
+        public DeleteCommandOptions deleteCommandOptions;
+        public InfoCommandOptions infoCommandOptions;
+
+
+    public WorkflowsCommandOptions(CommonCommandOptions commonCommandOptions, JCommander jCommander) {
+    
+        this.jCommander = jCommander;
+        this.commonCommandOptions = commonCommandOptions;
+        this.updateAclCommandOptions = new UpdateAclCommandOptions();
+        this.createCommandOptions = new CreateCommandOptions();
+        this.distinctCommandOptions = new DistinctCommandOptions();
+        this.importCommandOptions = new ImportCommandOptions();
+        this.runCommandOptions = new RunCommandOptions();
+        this.searchCommandOptions = new SearchCommandOptions();
+        this.updateCommandOptions = new UpdateCommandOptions();
+        this.aclCommandOptions = new AclCommandOptions();
+        this.deleteCommandOptions = new DeleteCommandOptions();
+        this.infoCommandOptions = new InfoCommandOptions();
+    
+    }
+    
+    @Parameters(commandNames = {"acl-update"}, commandDescription ="Update the set of permissions granted for the member")
+    public class UpdateAclCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--members"}, description = "Comma separated list of user or group ids", required = true, arity = 1)
+        public String members; 
+    
+        @Parameter(names = {"--action"}, description = "Action to be performed [ADD, SET, REMOVE or RESET].", required = true, arity = 1)
+        public String action = "ADD"; 
+    
+        @Parameter(names = {"--workflow-ids"}, description = "The body web service workflowIds parameter", required = false, arity = 1)
+        public String workflowIds;
+    
+        @Parameter(names = {"--permissions"}, description = "The body web service permissions parameter", required = false, arity = 1)
+        public String permissions;
+    
+    }
+
+    @Parameters(commandNames = {"create"}, commandDescription ="Create a workflow")
+    public class CreateCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--include", "-I"}, description = "Fields included in the response, whole JSON path must be provided", required = false, arity = 1)
+        public String include; 
+    
+        @Parameter(names = {"--exclude", "-E"}, description = "Fields excluded in the response, whole JSON path must be provided", required = false, arity = 1)
+        public String exclude; 
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--include-result"}, description = "Flag indicating to include the created or updated document result in the response", required = false, help = true, arity = 0)
+        public boolean includeResult = false; 
+    
+        @Parameter(names = {"--id"}, description = "Workflow ID.", required = true, arity = 1)
+        public String id;
+    
+        @Parameter(names = {"--name", "-n"}, description = "Workflow name.", required = false, arity = 1)
+        public String name;
+    
+        @Parameter(names = {"--description"}, description = "Users may provide a description for the entry.", required = false, arity = 1)
+        public String description;
+    
+        @Parameter(names = {"--manager-id"}, description = "Workflow system id. Valid values: NEXTFLOW.", required = false, arity = 1)
+        public String managerId;
+    
+        @Parameter(names = {"--manager-version"}, description = "Workflow system id. Valid values: NEXTFLOW.", required = false, arity = 1)
+        public String managerVersion;
+    
+        @Parameter(names = {"--type"}, description = "Workflow type. Valid values: NEXTFLOW.", required = false, arity = 1)
+        public String type;
+    
+        @Parameter(names = {"--tags"}, description = "List of tags.", required = false, arity = 1)
+        public String tags;
+    
+        @Parameter(names = {"--draft"}, description = "Flag indicating whether the workflow is still a draft or not.", required = false, help = true, arity = 0)
+        public boolean draft = false;
+    
+        @Parameter(names = {"--repository-id"}, description = "The body web service id parameter", required = false, arity = 1)
+        public String repositoryId;
+    
+        @Parameter(names = {"--repository-version"}, description = "The body web service version parameter", required = false, arity = 1)
+        public String repositoryVersion;
+    
+        @Parameter(names = {"--repository-author"}, description = "The body web service author parameter", required = false, arity = 1)
+        public String repositoryAuthor;
+    
+        @Parameter(names = {"--repository-description"}, description = "The body web service description parameter", required = false, arity = 1)
+        public String repositoryDescription;
+    
+        @Parameter(names = {"--minimum-requirements-cpu"}, description = "Minimum number of cpu cores required to execute the workflow.", required = false, arity = 1)
+        public String minimumRequirementsCpu;
+    
+        @Parameter(names = {"--minimum-requirements-memory"}, description = "Minimum memory required to execute the workflow (expressed in GB).", required = false, arity = 1)
+        public String minimumRequirementsMemory;
+    
+        @Parameter(names = {"--minimum-requirements-disk"}, description = "Minimum disk required to execute the workflow", required = false, arity = 1)
+        public String minimumRequirementsDisk;
+    
+        @Parameter(names = {"--creation-date", "--cd"}, description = "Autogenerated date following the format YYYYMMDDhhmmss containing the date when the entry was first registered.", required = false, arity = 1)
+        public String creationDate;
+    
+        @Parameter(names = {"--modification-date", "--md"}, description = "Autogenerated date following the format YYYYMMDDhhmmss containing the date when the entry was last modified.", required = false, arity = 1)
+        public String modificationDate;
+    
+        @DynamicParameter(names = {"--attributes"}, description = "You can use this field to store any other information, keep in mind this is not indexed so you cannot search by attributes.. Use: --attributes key=value", required = false)
+        public java.util.Map<java.lang.String,java.lang.Object> attributes = new HashMap<>(); //Dynamic parameters must be initialized;
+    
+    }
+
+    @Parameters(commandNames = {"distinct"}, commandDescription ="Workflow distinct method")
+    public class DistinctCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--id"}, description = "Comma separated list of workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.", required = false, arity = 1)
+        public String id; 
+    
+        @Parameter(names = {"--name", "-n"}, description = "Comma separated list of workflow names up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.", required = false, arity = 1)
+        public String name; 
+    
+        @Parameter(names = {"--uuid"}, description = "Comma separated list of workflow UUIDs up to a maximum of 100", required = false, arity = 1)
+        public String uuid; 
+    
+        @Parameter(names = {"--tags"}, description = "Comma separated list of tags", required = false, arity = 1)
+        public String tags; 
+    
+        @Parameter(names = {"--draft"}, description = "Boolean field indicating whether the workflow is a draft or not.", required = false, arity = 1)
+        public Boolean draft; 
+    
+        @Parameter(names = {"--internal.registration-user-id"}, description = "UserId that created the workflow.", required = false, arity = 1)
+        public String internalRegistrationUserId; 
+    
+        @Parameter(names = {"--manager.id"}, description = "Id of the workflow system (Allowed values: NEXTFLOW).", required = false, arity = 1)
+        public String managerId; 
+    
+        @Parameter(names = {"--type"}, description = "Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER]", required = false, arity = 1)
+        public String type; 
+    
+        @Parameter(names = {"--creation-date", "--cd"}, description = "Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805", required = false, arity = 1)
+        public String creationDate; 
+    
+        @Parameter(names = {"--modification-date", "--md"}, description = "Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805", required = false, arity = 1)
+        public String modificationDate; 
+    
+        @Parameter(names = {"--acl"}, description = "Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example: acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS permissions. Only study owners or administrators can query by this field. ", required = false, arity = 1)
+        public String acl; 
+    
+        @Parameter(names = {"--release"}, description = "Release when it was created", required = false, arity = 1)
+        public String release; 
+    
+        @Parameter(names = {"--snapshot"}, description = "Snapshot value (Latest version of the entry in the specified release)", required = false, arity = 1)
+        public Integer snapshot; 
+    
+        @Parameter(names = {"--deleted"}, description = "Boolean to retrieve deleted entries", required = false, help = true, arity = 0)
+        public boolean deleted = false; 
+    
+        @Parameter(names = {"--field"}, description = "Comma separated list of fields for which to obtain the distinct values", required = true, arity = 1)
+        public String field; 
+    
+    }
+
+    @Parameters(commandNames = {"import"}, commandDescription ="Execute a Nextflow analysis.")
+    public class ImportCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--id"}, description = "The body web service id parameter", required = false, arity = 1)
+        public String id;
+    
+        @Parameter(names = {"--version"}, description = "The body web service version parameter", required = false, arity = 1)
+        public String version;
+    
+    }
+
+    @Parameters(commandNames = {"run"}, commandDescription ="Execute a Nextflow analysis.")
+    public class RunCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--job-id"}, description = "Job ID. It must be a unique string within the study. An ID will be autogenerated automatically if not provided.", required = false, arity = 1)
+        public String jobId; 
+    
+        @Parameter(names = {"--job-description"}, description = "Job description", required = false, arity = 1)
+        public String jobDescription; 
+    
+        @Parameter(names = {"--job-depends-on"}, description = "Comma separated list of existing job IDs the job will depend on.", required = false, arity = 1)
+        public String jobDependsOn; 
+    
+        @Parameter(names = {"--job-tags"}, description = "Job tags", required = false, arity = 1)
+        public String jobTags; 
+    
+        @Parameter(names = {"--job-scheduled-start-time"}, description = "Time when the job is scheduled to start.", required = false, arity = 1)
+        public String jobScheduledStartTime; 
+    
+        @Parameter(names = {"--job-priority"}, description = "Priority of the job", required = false, arity = 1)
+        public String jobPriority; 
+    
+        @Parameter(names = {"--job-dry-run"}, description = "Flag indicating that the job will be executed in dry-run mode. In this mode, OpenCGA will validate that all parameters and prerequisites are correctly set for successful execution, but the job will not actually run.", required = false, arity = 1)
+        public Boolean jobDryRun; 
+    
+        @Parameter(names = {"--id"}, description = "The body web service id parameter", required = false, arity = 1)
+        public String id;
+    
+        @Parameter(names = {"--version"}, description = "The body web service version parameter", required = false, arity = 1)
+        public Integer version;
+    
+        @DynamicParameter(names = {"--params"}, description = "The body web service params parameter. Use: --params key=value", required = false)
+        public java.util.Map<java.lang.String,java.lang.String> params = new HashMap<>(); //Dynamic parameters must be initialized;
+    
+    }
+
+    @Parameters(commandNames = {"search"}, commandDescription ="Workflow search method")
+    public class SearchCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--include", "-I"}, description = "Fields included in the response, whole JSON path must be provided", required = false, arity = 1)
+        public String include; 
+    
+        @Parameter(names = {"--exclude", "-E"}, description = "Fields excluded in the response, whole JSON path must be provided", required = false, arity = 1)
+        public String exclude; 
+    
+        @Parameter(names = {"--limit"}, description = "Number of results to be returned", required = false, arity = 1)
+        public Integer limit; 
+    
+        @Parameter(names = {"--skip"}, description = "Number of results to skip", required = false, arity = 1)
+        public Integer skip; 
+    
+        @Parameter(names = {"--count"}, description = "Get the total number of results matching the query. Deactivated by default.", required = false, help = true, arity = 0)
+        public boolean count = false; 
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--id"}, description = "Comma separated list of workflow IDs up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.", required = false, arity = 1)
+        public String id; 
+    
+        @Parameter(names = {"--name", "-n"}, description = "Comma separated list of workflow names up to a maximum of 100. Also admits basic regular expressions using the operator '~', i.e. '~{perl-regex}' e.g. '~value' for case sensitive, '~/value/i' for case insensitive search.", required = false, arity = 1)
+        public String name; 
+    
+        @Parameter(names = {"--uuid"}, description = "Comma separated list of workflow UUIDs up to a maximum of 100", required = false, arity = 1)
+        public String uuid; 
+    
+        @Parameter(names = {"--tags"}, description = "Comma separated list of tags", required = false, arity = 1)
+        public String tags; 
+    
+        @Parameter(names = {"--draft"}, description = "Boolean field indicating whether the workflow is a draft or not.", required = false, arity = 1)
+        public Boolean draft; 
+    
+        @Parameter(names = {"--internal.registration-user-id"}, description = "UserId that created the workflow.", required = false, arity = 1)
+        public String internalRegistrationUserId; 
+    
+        @Parameter(names = {"--manager.id"}, description = "Id of the workflow system (Allowed values: NEXTFLOW).", required = false, arity = 1)
+        public String managerId; 
+    
+        @Parameter(names = {"--type"}, description = "Workflow type. Allowed types: [CLINICAL_INTERPRETATION, SECONDARY_ANALYSIS, RESEARCH or OTHER]", required = false, arity = 1)
+        public String type; 
+    
+        @Parameter(names = {"--creation-date", "--cd"}, description = "Creation date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805", required = false, arity = 1)
+        public String creationDate; 
+    
+        @Parameter(names = {"--modification-date", "--md"}, description = "Modification date. Format: yyyyMMddHHmmss. Examples: >2018, 2017-2018, <201805", required = false, arity = 1)
+        public String modificationDate; 
+    
+        @Parameter(names = {"--acl"}, description = "Filter entries for which a user has the provided permissions. Format: acl={user}:{permissions}. Example: acl=john:WRITE,WRITE_ANNOTATIONS will return all entries for which user john has both WRITE and WRITE_ANNOTATIONS permissions. Only study owners or administrators can query by this field. ", required = false, arity = 1)
+        public String acl; 
+    
+        @Parameter(names = {"--release"}, description = "Release when it was created", required = false, arity = 1)
+        public String release; 
+    
+        @Parameter(names = {"--snapshot"}, description = "Snapshot value (Latest version of the entry in the specified release)", required = false, arity = 1)
+        public Integer snapshot; 
+    
+        @Parameter(names = {"--deleted"}, description = "Boolean to retrieve deleted entries", required = false, help = true, arity = 0)
+        public boolean deleted = false; 
+    
+    }
+
+    @Parameters(commandNames = {"update"}, commandDescription ="Update some workflow attributes")
+    public class UpdateCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--json-file"}, description = "File with the body data in JSON format. Note, that using this parameter will ignore all the other parameters.", required = false, arity = 1)
+        public String jsonFile;
+    
+        @Parameter(names = {"--json-data-model"}, description = "Show example of file structure for body data.", help = true, arity = 0)
+        public Boolean jsonDataModel = false;
+    
+        @Parameter(names = {"--include", "-I"}, description = "Fields included in the response, whole JSON path must be provided", required = false, arity = 1)
+        public String include; 
+    
+        @Parameter(names = {"--exclude", "-E"}, description = "Fields excluded in the response, whole JSON path must be provided", required = false, arity = 1)
+        public String exclude; 
+    
+        @Parameter(names = {"--workflow-id"}, description = "Comma separated list workflow IDs or UUIDs up to a maximum of 100", required = true, arity = 1)
+        public String workflowId; 
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--include-result"}, description = "Flag indicating to include the created or updated document result in the response", required = false, help = true, arity = 0)
+        public boolean includeResult = false; 
+    
+        @Parameter(names = {"--name", "-n"}, description = "Workflow name.", required = false, arity = 1)
+        public String name;
+    
+        @Parameter(names = {"--description"}, description = "Users may provide a description for the entry.", required = false, arity = 1)
+        public String description;
+    
+        @Parameter(names = {"--manager-id"}, description = "Workflow system id. Valid values: NEXTFLOW.", required = false, arity = 1)
+        public String managerId;
+    
+        @Parameter(names = {"--manager-version"}, description = "Workflow system id. Valid values: NEXTFLOW.", required = false, arity = 1)
+        public String managerVersion;
+    
+        @Parameter(names = {"--type"}, description = "Workflow type. Valid values: NEXTFLOW.", required = false, arity = 1)
+        public String type;
+    
+        @Parameter(names = {"--tags"}, description = "List of tags.", required = false, arity = 1)
+        public String tags;
+    
+        @Parameter(names = {"--draft"}, description = "Flag indicating whether the workflow is still a draft or not.", required = false, help = true, arity = 0)
+        public boolean draft = false;
+    
+        @Parameter(names = {"--repository-id"}, description = "The body web service id parameter", required = false, arity = 1)
+        public String repositoryId;
+    
+        @Parameter(names = {"--repository-version"}, description = "The body web service version parameter", required = false, arity = 1)
+        public String repositoryVersion;
+    
+        @Parameter(names = {"--repository-author"}, description = "The body web service author parameter", required = false, arity = 1)
+        public String repositoryAuthor;
+    
+        @Parameter(names = {"--repository-description"}, description = "The body web service description parameter", required = false, arity = 1)
+        public String repositoryDescription;
+    
+        @Parameter(names = {"--creation-date", "--cd"}, description = "Autogenerated date following the format YYYYMMDDhhmmss containing the date when the entry was first registered.", required = false, arity = 1)
+        public String creationDate;
+    
+        @Parameter(names = {"--modification-date", "--md"}, description = "Autogenerated date following the format YYYYMMDDhhmmss containing the date when the entry was last modified.", required = false, arity = 1)
+        public String modificationDate;
+    
+        @DynamicParameter(names = {"--attributes"}, description = "You can use this field to store any other information, keep in mind this is not indexed so you cannot search by attributes.. Use: --attributes key=value", required = false)
+        public java.util.Map<java.lang.String,java.lang.Object> attributes = new HashMap<>(); //Dynamic parameters must be initialized;
+    
+    }
+
+    @Parameters(commandNames = {"acl"}, commandDescription ="Returns the acl of the workflows. If member is provided, it will only return the acl for the member.")
+    public class AclCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--workflows"}, description = "Comma separated list workflow IDs or UUIDs up to a maximum of 100", required = true, arity = 1)
+        public String workflows; 
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--member"}, description = "User or group id", required = false, arity = 1)
+        public String member; 
+    
+        @Parameter(names = {"--silent"}, description = "Boolean to retrieve all possible entries that are queried for, false to raise an exception whenever one of the entries looked for cannot be shown for whichever reason", required = false, help = true, arity = 0)
+        public boolean silent = false; 
+    
+    }
+
+    @Parameters(commandNames = {"delete"}, commandDescription ="Delete workflows")
+    public class DeleteCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--workflows"}, description = "Comma separated list workflow IDs or UUIDs up to a maximum of 100", required = true, arity = 1)
+        public String workflows; 
+    
+    }
+
+    @Parameters(commandNames = {"info"}, commandDescription ="Get workflow information")
+    public class InfoCommandOptions {
+    
+        @ParametersDelegate
+        public CommonCommandOptions commonOptions = commonCommandOptions;
+    
+        @Parameter(names = {"--include", "-I"}, description = "Fields included in the response, whole JSON path must be provided", required = false, arity = 1)
+        public String include; 
+    
+        @Parameter(names = {"--exclude", "-E"}, description = "Fields excluded in the response, whole JSON path must be provided", required = false, arity = 1)
+        public String exclude; 
+    
+        @Parameter(names = {"--workflows"}, description = "Comma separated list sample IDs or UUIDs up to a maximum of 100", required = true, arity = 1)
+        public String workflows; 
+    
+        @Parameter(names = {"--study", "-s"}, description = "Study [[organization@]project:]study where study and project can be either the ID or UUID", required = false, arity = 1)
+        public String study; 
+    
+        @Parameter(names = {"--version"}, description = "Comma separated list of workflow versions. 'all' to get all the workflow versions. Not supported if multiple workflow ids are provided", required = false, arity = 1)
+        public String version; 
+    
+        @Parameter(names = {"--deleted"}, description = "Boolean to retrieve deleted entries", required = false, help = true, arity = 0)
+        public boolean deleted = false; 
+    
+    }
+
+}
\ No newline at end of file
diff --git a/opencga-client/src/main/R/R/Workflow-methods.R b/opencga-client/src/main/R/R/Workflow-methods.R
index 1e7736bac30..1d7695d4e9e 100644
--- a/opencga-client/src/main/R/R/Workflow-methods.R
+++ b/opencga-client/src/main/R/R/Workflow-methods.R
@@ -22,6 +22,7 @@
 #' | updateAcl | /{apiVersion}/workflows/acl/{members}/update | study, members[*], action[*], body[*] |
 #' | create | /{apiVersion}/workflows/create | include, exclude, study, includeResult, body[*] |
 #' | distinct | /{apiVersion}/workflows/distinct | study, id, name, uuid, tags, draft, internal.registrationUserId, manager.id, type, creationDate, modificationDate, acl, release, snapshot, deleted, field[*] |
+#' | importWorkflow | /{apiVersion}/workflows/import | study, body[*] |
 #' | run | /{apiVersion}/workflows/run | study, jobId, jobDescription, jobDependsOn, jobTags, jobScheduledStartTime, jobPriority, jobDryRun, body[*] |
 #' | search | /{apiVersion}/workflows/search | include, exclude, limit, skip, count, study, id, name, uuid, tags, draft, internal.registrationUserId, manager.id, type, creationDate, modificationDate, acl, release, snapshot, deleted |
 #' | update | /{apiVersion}/workflows/{workflowId}/update | include, exclude, workflowId[*], study, includeResult, body |
@@ -79,6 +80,13 @@ setMethod("workflowClient", "OpencgaR", function(OpencgaR, members, workflowId,
         distinct=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory=NULL,
                 subcategoryId=NULL, action="distinct", params=params, httpMethod="GET", as.queryParam=c("field"), ...),
 
+        #' @section Endpoint /{apiVersion}/workflows/import:
+        #' Execute a Nextflow analysis.
+        #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
+        #' @param data Repository parameters.
+        importWorkflow=fetchOpenCGA(object=OpencgaR, category="workflows", categoryId=NULL, subcategory=NULL,
+                subcategoryId=NULL, action="import", params=params, httpMethod="POST", as.queryParam=NULL, ...),
+
         #' @section Endpoint /{apiVersion}/workflows/run:
         #' Execute a Nextflow analysis.
         #' @param study Study [[organization@]project:]study where study and project can be either the ID or UUID.
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/OpenCGAClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/OpenCGAClient.java
index 263bb992771..0e5e816faac 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/OpenCGAClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/OpenCGAClient.java
@@ -33,9 +33,7 @@
 import java.util.concurrent.TimeUnit;
 import java.util.function.Supplier;
 
-/**
- * Created by imedina on 04/05/16.
- */
+
 public class OpenCGAClient {
 
     protected String userId;
@@ -73,7 +71,7 @@ protected static String getUserFromToken(String token) {
     }
 
     private void init(AuthenticationResponse tokens, ClientConfiguration clientConfiguration) {
-        this.clients = new HashMap<>(25);
+        this.clients = new HashMap<>(30);
 
         if (tokens != null) {
             setToken(tokens.getToken());
@@ -81,9 +79,7 @@ private void init(AuthenticationResponse tokens, ClientConfiguration clientConfi
             this.userId = getUserFromToken(tokens.getToken());
         }
 
-
         this.clientConfiguration = clientConfiguration;
-
     }
 
     public OrganizationClient getOrganizationClient() {
@@ -110,32 +106,28 @@ public JobClient getJobClient() {
         return getClient(JobClient.class, () -> new JobClient(token, clientConfiguration));
     }
 
-    public IndividualClient getIndividualClient() {
-        return getClient(IndividualClient.class, () -> new IndividualClient(token, clientConfiguration));
-    }
-
     public SampleClient getSampleClient() {
         return getClient(SampleClient.class, () -> new SampleClient(token, clientConfiguration));
     }
 
-    public AdminClient getAdminClient() {
-        return getClient(AdminClient.class, () -> new AdminClient(token, clientConfiguration));
+    public IndividualClient getIndividualClient() {
+        return getClient(IndividualClient.class, () -> new IndividualClient(token, clientConfiguration));
     }
 
-    public CohortClient getCohortClient() {
-        return getClient(CohortClient.class, () -> new CohortClient(token, clientConfiguration));
+    public FamilyClient getFamilyClient() {
+        return getClient(FamilyClient.class, () -> new FamilyClient(token, clientConfiguration));
     }
 
-    public ClinicalAnalysisClient getClinicalAnalysisClient() {
-        return getClient(ClinicalAnalysisClient.class, () -> new ClinicalAnalysisClient(token, clientConfiguration));
+    public CohortClient getCohortClient() {
+        return getClient(CohortClient.class, () -> new CohortClient(token, clientConfiguration));
     }
 
     public DiseasePanelClient getDiseasePanelClient() {
         return getClient(DiseasePanelClient.class, () -> new DiseasePanelClient(token, clientConfiguration));
     }
 
-    public FamilyClient getFamilyClient() {
-        return getClient(FamilyClient.class, () -> new FamilyClient(token, clientConfiguration));
+    public WorkflowClient getWorkflowClient() {
+        return getClient(WorkflowClient.class, () -> new WorkflowClient(token, clientConfiguration));
     }
 
     public AlignmentClient getAlignmentClient() {
@@ -146,6 +138,10 @@ public VariantClient getVariantClient() {
         return getClient(VariantClient.class, () -> new VariantClient(token, clientConfiguration));
     }
 
+    public ClinicalAnalysisClient getClinicalAnalysisClient() {
+        return getClient(ClinicalAnalysisClient.class, () -> new ClinicalAnalysisClient(token, clientConfiguration));
+    }
+
     public VariantOperationClient getVariantOperationClient() {
         return getClient(VariantOperationClient.class, () -> new VariantOperationClient(token, clientConfiguration));
     }
@@ -154,6 +150,10 @@ public MetaClient getMetaClient() {
         return getClient(MetaClient.class, () -> new MetaClient(token, clientConfiguration));
     }
 
+    public AdminClient getAdminClient() {
+        return getClient(AdminClient.class, () -> new AdminClient(token, clientConfiguration));
+    }
+
     @SuppressWarnings("unchecked")
     protected  <T extends AbstractParentClient> T getClient(Class<T> clazz, Supplier<T> constructor) {
         return (T) clients.computeIfAbsent(clazz.getName(), (k) -> {
@@ -194,7 +194,6 @@ public AuthenticationResponse login(String organizationId, String user, String p
         return login.firstResult();
     }
 
-
     /**
      * Logs in the user.
      *
diff --git a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
index 7627ba5e735..d9523cecc4f 100644
--- a/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
+++ b/opencga-client/src/main/java/org/opencb/opencga/client/rest/clients/WorkflowClient.java
@@ -27,6 +27,7 @@
 import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
 import org.opencb.opencga.core.models.workflow.WorkflowAclUpdateParams;
 import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
+import org.opencb.opencga.core.models.workflow.WorkflowRepositoryParams;
 import org.opencb.opencga.core.models.workflow.WorkflowUpdateParams;
 import org.opencb.opencga.core.response.RestResponse;
 
@@ -118,6 +119,20 @@ public RestResponse<Object> distinct(String field, ObjectMap params) throws Clie
         return execute("workflows", null, null, null, "distinct", params, GET, Object.class);
     }
 
+    /**
+     * Execute a Nextflow analysis.
+     * @param data Repository parameters.
+     * @param params Map containing any of the following optional parameters.
+     *       study: Study [[organization@]project:]study where study and project can be either the ID or UUID.
+     * @return a RestResponse object.
+     * @throws ClientException ClientException if there is any server error.
+     */
+    public RestResponse<Job> importWorkflow(WorkflowRepositoryParams data, ObjectMap params) throws ClientException {
+        params = params != null ? params : new ObjectMap();
+        params.put("body", data);
+        return execute("workflows", null, null, null, "import", params, POST, Job.class);
+    }
+
     /**
      * Execute a Nextflow analysis.
      * @param data NextFlow run parameters.
diff --git a/opencga-client/src/main/javascript/Workflow.js b/opencga-client/src/main/javascript/Workflow.js
index b1c93077a60..7d6edc607c2 100644
--- a/opencga-client/src/main/javascript/Workflow.js
+++ b/opencga-client/src/main/javascript/Workflow.js
@@ -88,6 +88,16 @@ export default class Workflow extends OpenCGAParentClass {
         return this._get("workflows", null, null, null, "distinct", {field, ...params});
     }
 
+    /** Execute a Nextflow analysis.
+    * @param {Object} data - Repository parameters.
+    * @param {Object} [params] - The Object containing the following optional parameters:
+    * @param {String} [params.study] - Study [[organization@]project:]study where study and project can be either the ID or UUID.
+    * @returns {Promise} Promise object in the form of RestResponse instance.
+    */
+    importWorkflow(data, params) {
+        return this._post("workflows", null, null, null, "import", data, params);
+    }
+
     /** Execute a Nextflow analysis.
     * @param {Object} data - NextFlow run parameters.
     * @param {Object} [params] - The Object containing the following optional parameters:
diff --git a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
index 8ac5c76b851..cee7bf3500e 100644
--- a/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
+++ b/opencga-client/src/main/python/pyopencga/rest_clients/workflow_client.py
@@ -101,6 +101,18 @@ def distinct(self, field, **options):
         options['field'] = field
         return self._get(category='workflows', resource='distinct', **options)
 
+    def import_workflow(self, data=None, **options):
+        """
+        Execute a Nextflow analysis.
+        PATH: /{apiVersion}/workflows/import
+
+        :param dict data: Repository parameters. (REQUIRED)
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        """
+
+        return self._post(category='workflows', resource='import', data=data, **options)
+
     def run(self, data=None, **options):
         """
         Execute a Nextflow analysis.
diff --git a/opencga-server/src/main/resources/cli-config.yaml b/opencga-server/src/main/resources/cli-config.yaml
index 43a8143bac8..11986cd659a 100644
--- a/opencga-server/src/main/resources/cli-config.yaml
+++ b/opencga-server/src/main/resources/cli-config.yaml
@@ -156,6 +156,14 @@ apiConfig:
         - name: import
           ## Rename needed as `import` is a reserved word in Java
           rename: importPanels
+    - name: workflows
+      commandName: workflows
+      ignore: False
+      key: Workflow
+      commands:
+        - name: import
+          ## Rename needed as `import` is a reserved word in Java
+          rename: importWorkflow
     - name: analysisAlignment
       commandName: alignments
       ignore: False

From 9f9353140f253c54d92f5e4ee348555efceb3eaf Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 23 Oct 2024 11:13:36 +0200
Subject: [PATCH 89/99] master: fix daemon to use correct tool id, #TASK-6445

---
 .../opencga/analysis/tools/ToolFactory.java   | 16 ++++++++++++---
 .../executors/WorkflowsCommandExecutor.java   |  6 +++---
 .../main/options/WorkflowsCommandOptions.java |  6 +++---
 .../catalog/managers/WorkflowManager.java     |  4 ++--
 .../workflow/WorkflowMinimumRequirements.java | 20 +++++++++----------
 .../monitor/daemons/ExecutionDaemon.java      |  8 +++-----
 6 files changed, 34 insertions(+), 26 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolFactory.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolFactory.java
index ba31a2eb4a4..16b464c39b1 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolFactory.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolFactory.java
@@ -18,6 +18,7 @@
 
 import org.apache.commons.lang3.StringUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.job.ToolInfo;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.reflections.Reflections;
 import org.reflections.scanners.SubTypesScanner;
@@ -137,14 +138,23 @@ public final Class<? extends OpenCgaTool> getToolClass(String toolId, List<Strin
         return aClass;
     }
 
-    public Tool getTool(String toolId) throws ToolException {
-        return getTool(toolId, Collections.singletonList(DEFAULT_PACKAGE));
+    public Tool getTool(ToolInfo toolInfo) throws ToolException {
+        return getTool(toolInfo, Collections.singletonList(DEFAULT_PACKAGE));
     }
 
-    public Tool getTool(String toolId, List<String> packages) throws ToolException {
+    public Tool getTool(ToolInfo toolInfo, List<String> packages) throws ToolException {
+        String toolId = getToolId(toolInfo);
         return getToolClass(toolId, packages).getAnnotation(Tool.class);
     }
 
+    public static String getToolId(ToolInfo toolInfo) {
+        if (toolInfo.getExternalExecutor() != null && StringUtils.isNotEmpty(toolInfo.getExternalExecutor().getId())) {
+            return toolInfo.getExternalExecutor().getId();
+        } else {
+            return toolInfo.getId();
+        }
+    }
+
     public final OpenCgaTool createTool(String toolId) throws ToolException {
         return createTool(toolId, Collections.singletonList(DEFAULT_PACKAGE));
     }
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
index f910b4f80be..29bca426dfd 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
@@ -171,9 +171,9 @@ private RestResponse<Workflow> create() throws Exception {
             putNestedIfNotEmpty(beanParams, "repository.version", commandOptions.repositoryVersion, true);
             putNestedIfNotEmpty(beanParams, "repository.author", commandOptions.repositoryAuthor, true);
             putNestedIfNotEmpty(beanParams, "repository.description", commandOptions.repositoryDescription, true);
-            putNestedIfNotEmpty(beanParams, "minimumRequirements.cpu", commandOptions.minimumRequirementsCpu, true);
-            putNestedIfNotEmpty(beanParams, "minimumRequirements.memory", commandOptions.minimumRequirementsMemory, true);
-            putNestedIfNotEmpty(beanParams, "minimumRequirements.disk", commandOptions.minimumRequirementsDisk, true);
+            putNestedIfNotNull(beanParams, "minimumRequirements.cpu", commandOptions.minimumRequirementsCpu, true);
+            putNestedIfNotNull(beanParams, "minimumRequirements.memory", commandOptions.minimumRequirementsMemory, true);
+            putNestedIfNotNull(beanParams, "minimumRequirements.disk", commandOptions.minimumRequirementsDisk, true);
             putNestedIfNotEmpty(beanParams, "creationDate", commandOptions.creationDate, true);
             putNestedIfNotEmpty(beanParams, "modificationDate", commandOptions.modificationDate, true);
             putNestedMapIfNotEmpty(beanParams, "attributes", commandOptions.attributes, true);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java
index c395b9c8d62..4e286527062 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java
@@ -152,13 +152,13 @@ public class CreateCommandOptions {
         public String repositoryDescription;
     
         @Parameter(names = {"--minimum-requirements-cpu"}, description = "Minimum number of cpu cores required to execute the workflow.", required = false, arity = 1)
-        public String minimumRequirementsCpu;
+        public Integer minimumRequirementsCpu;
     
         @Parameter(names = {"--minimum-requirements-memory"}, description = "Minimum memory required to execute the workflow (expressed in GB).", required = false, arity = 1)
-        public String minimumRequirementsMemory;
+        public Integer minimumRequirementsMemory;
     
         @Parameter(names = {"--minimum-requirements-disk"}, description = "Minimum disk required to execute the workflow", required = false, arity = 1)
-        public String minimumRequirementsDisk;
+        public Integer minimumRequirementsDisk;
     
         @Parameter(names = {"--creation-date", "--cd"}, description = "Autogenerated date following the format YYYYMMDDhhmmss containing the date when the entry was first registered.", required = false, arity = 1)
         public String creationDate;
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index d6d5c2c6110..93d202fa3e7 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -402,10 +402,10 @@ private void fillWithGitpodManifest(Workflow workflow, String rawline) {
         String value = split[1].replace("\"", "").replace("'", "").trim();
         switch (key) {
             case "executor.cpus":
-                workflow.getMinimumRequirements().setCpu(value);
+                workflow.getMinimumRequirements().setCpu(Integer.valueOf(value));
                 break;
             case "executor.memory":
-                workflow.getMinimumRequirements().setMemory(value.replace(".", ""));
+                workflow.getMinimumRequirements().setMemory(Integer.valueOf(value.split("\\.")[0]));
                 break;
             default:
                 break;
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
index 0f4a33b058b..6f045ff3ce5 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
@@ -6,18 +6,18 @@
 public class WorkflowMinimumRequirements {
 
     @DataField(id = "cpu", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_CPU_DESCRIPTION)
-    private String cpu;
+    private Integer cpu;
 
     @DataField(id = "memory", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_MEMORY_DESCRIPTION)
-    private String memory;
+    private Integer memory;
 
     @DataField(id = "disk", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_DISK_DESCRIPTION)
-    private String disk;
+    private Integer disk;
 
     public WorkflowMinimumRequirements() {
     }
 
-    public WorkflowMinimumRequirements(String cpu, String memory, String disk) {
+    public WorkflowMinimumRequirements(Integer cpu, Integer memory, Integer disk) {
         this.cpu = cpu;
         this.memory = memory;
         this.disk = disk;
@@ -33,29 +33,29 @@ public String toString() {
         return sb.toString();
     }
 
-    public String getCpu() {
+    public Integer getCpu() {
         return cpu;
     }
 
-    public WorkflowMinimumRequirements setCpu(String cpu) {
+    public WorkflowMinimumRequirements setCpu(Integer cpu) {
         this.cpu = cpu;
         return this;
     }
 
-    public String getMemory() {
+    public Integer getMemory() {
         return memory;
     }
 
-    public WorkflowMinimumRequirements setMemory(String memory) {
+    public WorkflowMinimumRequirements setMemory(Integer memory) {
         this.memory = memory;
         return this;
     }
 
-    public String getDisk() {
+    public Integer getDisk() {
         return disk;
     }
 
-    public WorkflowMinimumRequirements setDisk(String disk) {
+    public WorkflowMinimumRequirements setDisk(Integer disk) {
         this.disk = disk;
         return this;
     }
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
index 5903164e493..bf38f980be9 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
@@ -560,7 +560,7 @@ protected int checkPendingJob(Job job) {
 
         Tool tool;
         try {
-            tool = new ToolFactory().getTool(job.getTool().getId(), packages);
+            tool = new ToolFactory().getTool(job.getTool(), packages);
         } catch (Exception e) {
             logger.error(e.getMessage(), e);
             return abortJob(job, "Tool " + job.getTool().getId() + " not found", e);
@@ -678,7 +678,7 @@ private boolean killSignalSent(Job job) {
     }
 
     protected void checkToolExecutionPermission(String organizationId, Job job) throws Exception {
-        Tool tool = new ToolFactory().getTool(job.getTool().getId(), packages);
+        Tool tool = new ToolFactory().getTool(job.getTool(), packages);
 
         AuthorizationManager authorizationManager = catalogManager.getAuthorizationManager();
         String user = job.getUserId();
@@ -850,9 +850,7 @@ private File getValidDefaultOutDir(String organizationId, Job job) throws Catalo
     }
 
     public static String buildCli(String internalCli, Job job) {
-        String toolId = job.getTool().getExternalExecutor() != null && StringUtils.isNotEmpty(job.getTool().getExternalExecutor().getId())
-                ? job.getTool().getExternalExecutor().getId()
-                : job.getTool().getId();
+        String toolId = ToolFactory.getToolId(job.getTool());
         String internalCommand = TOOL_CLI_MAP.get(toolId);
         if (StringUtils.isEmpty(internalCommand) || job.isDryRun()) {
             ObjectMap params = new ObjectMap()

From f63d3e9bc4065c590eec8094ec3a002b7a511327 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 23 Oct 2024 12:01:06 +0200
Subject: [PATCH 90/99] master: ensure only necessary ToolInfo fields are
 updated, #TASK-6445

---
 .../monitor/daemons/ExecutionDaemon.java      | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
index bf38f980be9..0771bff2ddc 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
@@ -544,8 +544,9 @@ protected int checkPendingJob(Job job) {
         CatalogFqn catalogFqn = CatalogFqn.extractFqnFromStudyFqn(job.getStudy().getId());
         String organizationId = catalogFqn.getOrganizationId();
 
-        if (StringUtils.isEmpty(job.getTool().getId())) {
-            return abortJob(job, "Tool id '" + job.getTool().getId() + "' not found.");
+        String toolId = ToolFactory.getToolId(job.getTool());
+        if (StringUtils.isEmpty(toolId)) {
+            return abortJob(job, "Tool id '" + toolId + "' not found.");
         }
 
         if (killSignalSent(job)) {
@@ -563,7 +564,7 @@ protected int checkPendingJob(Job job) {
             tool = new ToolFactory().getTool(job.getTool(), packages);
         } catch (Exception e) {
             logger.error(e.getMessage(), e);
-            return abortJob(job, "Tool " + job.getTool().getId() + " not found", e);
+            return abortJob(job, "Tool " + toolId + " not found", e);
         }
 
         try {
@@ -573,8 +574,10 @@ protected int checkPendingJob(Job job) {
         }
 
         PrivateJobUpdateParams updateParams = new PrivateJobUpdateParams();
-        updateParams.setTool(new ToolInfo(tool.id(), GitRepositoryState.getInstance().getBuildVersion(), tool.description(), tool.scope(),
-                tool.type(), tool.resource()));
+        updateToolInfoInformation(job.getTool());
+        updateParams.setTool(job.getTool());
+//        updateParams.setTool(new ToolInfo(tool.id(), GitRepositoryState.getInstance().getBuildVersion(), tool.description(), tool.scope(),
+//                tool.type(), tool.resource()));
 
         if (tool.scope() == Tool.Scope.PROJECT) {
             String projectFqn = job.getStudy().getId().substring(0, job.getStudy().getId().indexOf(ParamConstants.PROJECT_STUDY_SEPARATOR));
@@ -673,6 +676,18 @@ protected int checkPendingJob(Job job) {
         return 1;
     }
 
+    private void updateToolInfoInformation(ToolInfo toolInfo, Tool tool) {
+        if (StringUtils.isEmpty(toolInfo.getVersion())) {
+            toolInfo.setVersion(GitRepositoryState.getInstance().getBuildVersion());
+        }
+        if (StringUtils.isEmpty(toolInfo.getDescription())) {
+            toolInfo.setDescription(tool.description());
+        }
+        toolInfo.setScope(tool.scope());
+        toolInfo.setType(tool.type());
+        toolInfo.setResource(tool.resource());
+    }
+
     private boolean killSignalSent(Job job) {
         return job.getInternal().isKillJobRequested();
     }

From 0f518785f566abcea735e0c528e4ed2448226910 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 25 Oct 2024 13:32:03 +0200
Subject: [PATCH 91/99] catalog: ensure all jobs can be accessed by the owner,
 #TASK-6445

---
 .../org/opencb/opencga/catalog/managers/JobManager.java  | 9 +++++++++
 .../opencga/master/monitor/daemons/ExecutionDaemon.java  | 2 +-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
index 08e11bd5276..eee5e4a10f8 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
@@ -638,6 +638,15 @@ public OpenCGAResult<Job> submit(String studyStr, ToolInfo toolInfo, Enums.Prior
                 return reuseJob;
             } else {
                 getJobDBAdaptor(organizationId).insert(study.getUid(), job, new QueryOptions());
+
+                // Grant all job permissions to the user that generated the job
+                List<String> jobPermissions = EnumSet.allOf(JobPermissions.class)
+                        .stream()
+                        .map(JobPermissions::toString)
+                        .collect(Collectors.toList());
+                authorizationManager.setAcls(organizationId, study.getUid(), Collections.singletonList(userId),
+                        new AuthorizationManager.CatalogAclParams(Collections.singletonList(job.getUid()),
+                                jobPermissions, Enums.Resource.JOB));
                 OpenCGAResult<Job> jobResult = getJobDBAdaptor(organizationId).get(job.getUid(), new QueryOptions());
 
                 auditManager.auditCreate(organizationId, userId, Enums.Resource.JOB, job.getId(), "", study.getId(), study.getUuid(),
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
index 0771bff2ddc..8f367522f10 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
@@ -574,7 +574,7 @@ protected int checkPendingJob(Job job) {
         }
 
         PrivateJobUpdateParams updateParams = new PrivateJobUpdateParams();
-        updateToolInfoInformation(job.getTool());
+        updateToolInfoInformation(job.getTool(), tool);
         updateParams.setTool(job.getTool());
 //        updateParams.setTool(new ToolInfo(tool.id(), GitRepositoryState.getInstance().getBuildVersion(), tool.description(), tool.scope(),
 //                tool.type(), tool.resource()));

From fec2270f96cf0ded905d81b8aaf2bbc96021730d Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Thu, 7 Nov 2024 10:31:25 +0100
Subject: [PATCH 92/99] core: add new type field to Job, #TASK-6445

---
 .../alignment/qc/AlignmentQcAnalysis.java     |  7 +-
 .../opencga/analysis/file/FileLinkTask.java   |  3 +-
 .../analysis/sample/qc/SampleQcAnalysis.java  |  7 +-
 .../opencga/analysis/tools/ToolFactory.java   | 29 +++++---
 .../manager/VariantStorageManager.java        |  7 +-
 .../VariantFileIndexJobLauncherTool.java      |  3 +-
 .../operations/PlatinumFileIndexerTest.java   |  5 +-
 .../main/executors/JobsCommandExecutor.java   |  5 +-
 .../executors/WorkflowsCommandExecutor.java   |  8 +--
 .../cli/main/options/JobsCommandOptions.java  |  6 +-
 .../main/options/WorkflowsCommandOptions.java | 12 ++--
 .../managers/AnnotationSetManager.java        |  3 +-
 .../opencga/catalog/managers/JobManager.java  | 39 ++++++-----
 .../catalog/managers/WorkflowManager.java     | 22 +++---
 .../catalog/migration/MigrationManager.java   |  4 +-
 .../catalog/managers/CatalogManagerTest.java  | 44 ++++++------
 .../migration/MigrationManagerTest.java       |  3 +-
 .../opencga/core/api/FieldConstants.java      | 11 +--
 .../opencga/core/config/Configuration.java    |  5 +-
 .../core/config/WorkflowConfiguration.java    | 12 ++--
 .../WorkflowMinRequirementsConfiguration.java | 54 --------------
 .../opencb/opencga/core/models/job/Job.java   | 24 +++++--
 .../core/models/job/JobCreateParams.java      | 19 ++++-
 .../opencga/core/models/job/JobType.java      |  8 +++
 .../core/models/job/MinimumRequirements.java  | 62 ++++++++++++++++
 .../opencga/core/models/job/ToolInfo.java     | 39 +++--------
 .../core/models/workflow/Workflow.java        | 11 +--
 .../models/workflow/WorkflowCreateParams.java | 11 +--
 .../workflow/WorkflowMinimumRequirements.java | 62 ----------------
 .../models/workflow/WorkflowUpdateParams.java |  7 +-
 .../opencga/core/tools/ToolDependency.java    | 54 ++++++++++++++
 .../core/tools/result/ExecutionResult.java    |  4 ++
 .../monitor/daemons/ExecutionDaemon.java      | 16 ++---
 .../monitor/daemons/ExecutionDaemonTest.java  | 51 +++++++-------
 .../models/PrivateJobUpdateParamsTest.java    |  3 +-
 .../opencga/server/rest/FileWSServer.java     | 11 +--
 .../opencga/server/rest/JobWSServer.java      |  8 +--
 .../opencga/server/rest/OpenCGAWSServer.java  | 70 +++++++++----------
 .../opencga/server/rest/PanelWSServer.java    |  3 +-
 .../opencga/server/rest/StudyWSServer.java    |  3 +-
 .../rest/analysis/AlignmentWebService.java    | 19 ++---
 .../rest/analysis/ClinicalWebService.java     | 17 ++---
 .../rest/analysis/VariantWebService.java      | 51 +++++++-------
 .../VariantOperationWebService.java           | 11 +--
 44 files changed, 451 insertions(+), 402 deletions(-)
 delete mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowMinRequirementsConfiguration.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobType.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/job/MinimumRequirements.java
 delete mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
 create mode 100644 opencga-core/src/main/java/org/opencb/opencga/core/tools/ToolDependency.java

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/alignment/qc/AlignmentQcAnalysis.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/alignment/qc/AlignmentQcAnalysis.java
index 67ac836c36a..1ef413533c1 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/alignment/qc/AlignmentQcAnalysis.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/alignment/qc/AlignmentQcAnalysis.java
@@ -35,6 +35,7 @@
 import org.opencb.opencga.core.models.file.FileQualityControl;
 import org.opencb.opencga.core.models.file.FileUpdateParams;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
@@ -119,7 +120,7 @@ protected void run() throws ToolException {
                             .toParams(new ObjectMap(ParamConstants.STUDY_PARAM, study));
 
                     OpenCGAResult<Job> flagStatsJobResult = catalogManager.getJobManager()
-                            .submit(study, AlignmentFlagStatsAnalysis.ID, Enums.Priority.MEDIUM, params, null, "Job generated by "
+                            .submit(study, JobType.NATIVE, AlignmentFlagStatsAnalysis.ID, Enums.Priority.MEDIUM, params, null, "Job generated by "
                                     + getId() + " - " + getJobId(), Collections.emptyList(), Collections.emptyList(), getJobId(), null,
                                     false, token);
                     flagStatsJobId = flagStatsJobResult.first().getId();
@@ -137,7 +138,7 @@ protected void run() throws ToolException {
                             .toParams(new ObjectMap(ParamConstants.STUDY_PARAM, study));
 
                     OpenCGAResult<Job> statsJobResult = catalogManager.getJobManager()
-                            .submit(study, AlignmentStatsAnalysis.ID, Enums.Priority.MEDIUM, params, null, "Job generated by "
+                            .submit(study, JobType.NATIVE, AlignmentStatsAnalysis.ID, Enums.Priority.MEDIUM, params, null, "Job generated by "
                                     + getId() + " - " + getJobId(), Collections.emptyList(), Collections.emptyList(), getJobId(), null,
                                     false, token);
                     statsJobId = statsJobResult.first().getId();
@@ -154,7 +155,7 @@ protected void run() throws ToolException {
                             .toParams(new ObjectMap(ParamConstants.STUDY_PARAM, study));
 
                     OpenCGAResult<Job> fastQcMetricsJobResult = catalogManager.getJobManager()
-                            .submit(study, AlignmentFastQcMetricsAnalysis.ID, Enums.Priority.MEDIUM, params, null,
+                            .submit(study, JobType.NATIVE, AlignmentFastQcMetricsAnalysis.ID, Enums.Priority.MEDIUM, params, null,
                                     "Job generated by " + getId() + " - " + getJobId(), Collections.emptyList(), Collections.emptyList(),
                                     getJobId(), null, false, token);
                     fastQcMetricsJobId = fastQcMetricsJobResult.first().getId();
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/file/FileLinkTask.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/file/FileLinkTask.java
index 88cb038215a..935cb7ca8da 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/file/FileLinkTask.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/file/FileLinkTask.java
@@ -9,6 +9,7 @@
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.file.*;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
@@ -68,7 +69,7 @@ protected void run() throws Exception {
             Map<String, Object> params = new PostLinkToolParams(postLinkFileIds, null)
                     .toParams(new ObjectMap(ParamConstants.STUDY_PARAM, study));
             Job postLinkJob = catalogManager.getJobManager()
-                    .submit(getStudy(), PostLinkSampleAssociation.ID, Enums.Priority.MEDIUM, params, null,
+                    .submit(getStudy(), JobType.NATIVE, PostLinkSampleAssociation.ID, Enums.Priority.MEDIUM, params, null,
                             "Job generated by " + getId() + " - " + getJobId(), Collections.emptyList(), Collections.emptyList(),
                             getJobId(), null, false, getToken()).first();
             logger.info("Submit post-link job : " + postLinkJob.getId());
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/sample/qc/SampleQcAnalysis.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/sample/qc/SampleQcAnalysis.java
index b8d460824c1..89723243d9e 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/sample/qc/SampleQcAnalysis.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/sample/qc/SampleQcAnalysis.java
@@ -39,6 +39,7 @@
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.sample.Sample;
 import org.opencb.opencga.core.models.sample.SampleQualityControl;
 import org.opencb.opencga.core.models.sample.SampleUpdateParams;
@@ -224,7 +225,7 @@ protected void run() throws ToolException {
                             .toParams(new ObjectMap(ParamConstants.STUDY_PARAM, getStudy()));
 
                     OpenCGAResult<Job> variantStatsJobResult = catalogManager.getJobManager()
-                            .submit(study, SampleVariantStatsAnalysis.ID, Enums.Priority.MEDIUM, params, null, "Job generated by "
+                            .submit(study, JobType.NATIVE, SampleVariantStatsAnalysis.ID, Enums.Priority.MEDIUM, params, null, "Job generated by "
                                     + getId() + " - " + getJobId(), Collections.emptyList(), Collections.emptyList(), getJobId(), null,
                                     false, token);
                     variantStatsJobId = variantStatsJobResult.first().getId();
@@ -267,7 +268,7 @@ protected void run() throws ToolException {
                             .toParams(new ObjectMap(ParamConstants.STUDY_PARAM, getStudy()));
 
                     OpenCGAResult<Job> signatureJobResult = catalogManager.getJobManager()
-                            .submit(getStudy(), MutationalSignatureAnalysis.ID, Enums.Priority.MEDIUM, params, null, "Job generated by "
+                            .submit(getStudy(), JobType.NATIVE, MutationalSignatureAnalysis.ID, Enums.Priority.MEDIUM, params, null, "Job generated by "
                                     + getId() + " - " + getJobId(), Collections.emptyList(), Collections.emptyList(), getJobId(), null,
                                     false, token);
                     signatureJobId = signatureJobResult.first().getId();
@@ -289,7 +290,7 @@ protected void run() throws ToolException {
                             .toParams(new ObjectMap(ParamConstants.STUDY_PARAM, getStudy()));
 
                     OpenCGAResult<Job> genomePlotJobResult = catalogManager.getJobManager()
-                            .submit(getStudy(), GenomePlotAnalysis.ID, Enums.Priority.MEDIUM, params, null,
+                            .submit(getStudy(), JobType.NATIVE, GenomePlotAnalysis.ID, Enums.Priority.MEDIUM, params, null,
                                     "Job generated by " + getId() + " - " + getJobId(), Collections.emptyList(), Collections.emptyList(),
                                     getJobId(), null, false, token);
                     genomePlotJobId = genomePlotJobResult.first().getId();
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolFactory.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolFactory.java
index 16b464c39b1..4200568ddc4 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolFactory.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolFactory.java
@@ -17,7 +17,10 @@
 package org.opencb.opencga.analysis.tools;
 
 import org.apache.commons.lang3.StringUtils;
+import org.opencb.opencga.analysis.customTool.CustomToolExecutor;
+import org.opencb.opencga.analysis.workflow.NextFlowExecutor;
 import org.opencb.opencga.core.exceptions.ToolException;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.job.ToolInfo;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.reflections.Reflections;
@@ -138,20 +141,28 @@ public final Class<? extends OpenCgaTool> getToolClass(String toolId, List<Strin
         return aClass;
     }
 
-    public Tool getTool(ToolInfo toolInfo) throws ToolException {
-        return getTool(toolInfo, Collections.singletonList(DEFAULT_PACKAGE));
+    public Tool getTool(JobType type, ToolInfo toolInfo) throws ToolException {
+        return getTool(type, toolInfo, Collections.singletonList(DEFAULT_PACKAGE));
     }
 
-    public Tool getTool(ToolInfo toolInfo, List<String> packages) throws ToolException {
-        String toolId = getToolId(toolInfo);
+    public Tool getTool(JobType type, ToolInfo toolInfo, List<String> packages) throws ToolException {
+        String toolId = getToolId(type, toolInfo);
         return getToolClass(toolId, packages).getAnnotation(Tool.class);
     }
 
-    public static String getToolId(ToolInfo toolInfo) {
-        if (toolInfo.getExternalExecutor() != null && StringUtils.isNotEmpty(toolInfo.getExternalExecutor().getId())) {
-            return toolInfo.getExternalExecutor().getId();
-        } else {
-            return toolInfo.getId();
+    public static String getToolId(JobType type, ToolInfo toolInfo) {
+        switch (type) {
+            case NATIVE:
+                return toolInfo.getId();
+            case WORKFLOW:
+                return NextFlowExecutor.ID;
+            case CUSTOM:
+                return CustomToolExecutor.ID;
+            case WALKER:
+                // TODO: Call to WalkerExecutor
+                return toolInfo.getId();
+            default:
+                throw new IllegalStateException("Unexpected job type value: " + type);
         }
     }
 
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/variant/manager/VariantStorageManager.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/variant/manager/VariantStorageManager.java
index bd71414a4e8..d7e7c6e02c7 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/variant/manager/VariantStorageManager.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/variant/manager/VariantStorageManager.java
@@ -63,6 +63,7 @@
 import org.opencb.opencga.core.models.family.Family;
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.operations.variant.*;
 import org.opencb.opencga.core.models.project.DataStore;
 import org.opencb.opencga.core.models.project.Project;
@@ -568,7 +569,7 @@ public OpenCGAResult<Job> configureSampleIndex(String studyStr, SampleIndexConfi
                 // If changes, launch sample-index-run
                 ToolParams params =
                         new VariantSecondarySampleIndexParams(Collections.singletonList(ParamConstants.ALL), true, true, true, false);
-                return catalogManager.getJobManager().submit(studyFqn, VariantSecondarySampleIndexOperationTool.ID, null,
+                return catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, VariantSecondarySampleIndexOperationTool.ID, null,
                         params.toParams(STUDY_PARAM, studyFqn), token);
             }
         });
@@ -615,7 +616,7 @@ public OpenCGAResult<Job> setCellbaseConfiguration(String project, CellBaseConfi
                 if (StringUtils.isNotEmpty(annotationSaveId)) {
                     VariantAnnotationSaveParams params = new VariantAnnotationSaveParams(annotationSaveId);
                     OpenCGAResult<Job> saveResult = catalogManager.getJobManager()
-                            .submitProject(project, VariantAnnotationSaveOperationTool.ID, null, params.toParams(PROJECT_PARAM, project),
+                            .submitProject(project, JobType.NATIVE, VariantAnnotationSaveOperationTool.ID, null, params.toParams(PROJECT_PARAM, project),
                                     null, "Save variant annotation before changing cellbase configuration", null, null, token);
                     result.getResults().add(saveResult.first());
                     if (saveResult.getEvents() != null) {
@@ -626,7 +627,7 @@ public OpenCGAResult<Job> setCellbaseConfiguration(String project, CellBaseConfi
                 if (annotate) {
                     VariantAnnotationIndexParams params = new VariantAnnotationIndexParams().setOverwriteAnnotations(true);
                     OpenCGAResult<Job> annotResult = catalogManager.getJobManager()
-                            .submitProject(project, VariantAnnotationIndexOperationTool.ID, null, params.toParams(PROJECT_PARAM, project),
+                            .submitProject(project, JobType.NATIVE, VariantAnnotationIndexOperationTool.ID, null, params.toParams(PROJECT_PARAM, project),
                                     null, "Forced re-annotation after changing cellbase configuration", jobDependsOn, null, token);
                     result.getResults().add(annotResult.first());
                     if (annotResult.getEvents() != null) {
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/variant/operations/VariantFileIndexJobLauncherTool.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/variant/operations/VariantFileIndexJobLauncherTool.java
index f45b7011650..de915c720f6 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/variant/operations/VariantFileIndexJobLauncherTool.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/variant/operations/VariantFileIndexJobLauncherTool.java
@@ -16,6 +16,7 @@
 import org.opencb.opencga.core.models.file.FileInternal;
 import org.opencb.opencga.core.models.file.VariantIndexStatus;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.operations.variant.VariantFileIndexJobLauncherParams;
 import org.opencb.opencga.core.models.operations.variant.VariantIndexParams;
 import org.opencb.opencga.core.response.OpenCGAResult;
@@ -140,7 +141,7 @@ protected void run() throws Exception {
                     }
                 }
                 String jobId = buildJobId(file);
-                Job job = catalogManager.getJobManager().submit(getStudy(), VariantIndexOperationTool.ID, Enums.Priority.MEDIUM,
+                Job job = catalogManager.getJobManager().submit(getStudy(), JobType.NATIVE, VariantIndexOperationTool.ID, Enums.Priority.MEDIUM,
                         indexParams.toParams(new ObjectMap(ParamConstants.STUDY_PARAM, study)), jobId, "Job generated by " + getId(),
                         Collections.emptyList(), jobTags, getJobId(), null, false, getToken()).first();
                 submittedJobs++;
diff --git a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/variant/manager/operations/PlatinumFileIndexerTest.java b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/variant/manager/operations/PlatinumFileIndexerTest.java
index c343ceff241..bfa9c25c43e 100644
--- a/opencga-analysis/src/test/java/org/opencb/opencga/analysis/variant/manager/operations/PlatinumFileIndexerTest.java
+++ b/opencga-analysis/src/test/java/org/opencb/opencga/analysis/variant/manager/operations/PlatinumFileIndexerTest.java
@@ -33,6 +33,7 @@
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.operations.variant.VariantFileIndexJobLauncherParams;
 import org.opencb.opencga.core.models.operations.variant.VariantIndexParams;
 import org.opencb.opencga.core.testclassification.duration.MediumTests;
@@ -211,7 +212,7 @@ public void testLauncher() throws CatalogException, IOException, ToolException {
         }
         VariantFileIndexJobLauncherParams params = new VariantFileIndexJobLauncherParams().setDirectory("data/vcfs");
         List<String> tags = Arrays.asList("tag1", "tag2");
-        Job job = catalogManager.getJobManager().submit(studyFqn, VariantFileIndexJobLauncherTool.ID, Enums.Priority.HIGH,
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, VariantFileIndexJobLauncherTool.ID, Enums.Priority.HIGH,
                 params.toParams(STUDY_PARAM, studyFqn), null, null, null, tags, null, null, false, sessionId).first();
         ExecutionResult result = toolRunner.execute(job, Paths.get(opencga.createTmpOutdir(studyId, "_LOAD_", sessionId)), sessionId);
 
@@ -230,7 +231,7 @@ public void testLauncher() throws CatalogException, IOException, ToolException {
 
         //// Execute again, no new jobs should be submitted
         tags = Arrays.asList("tag10", "tag20");
-        job = catalogManager.getJobManager().submit(studyFqn, VariantFileIndexJobLauncherTool.ID, Enums.Priority.HIGH,
+        job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, VariantFileIndexJobLauncherTool.ID, Enums.Priority.HIGH,
                 params.toParams(STUDY_PARAM, studyFqn), null, null, null, tags, null, null, false, sessionId).first();
         result = toolRunner.execute(job, Paths.get(opencga.createTmpOutdir(studyId, "_LOAD_", sessionId)), sessionId);
 
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
index d741fb123ad..c6bd1d5db80 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/JobsCommandExecutor.java
@@ -29,9 +29,10 @@
 import org.opencb.opencga.core.models.job.JobToolBuildDockerParams;
 import org.opencb.opencga.core.models.job.JobToolBuildParams;
 import org.opencb.opencga.core.models.job.JobTop;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.job.JobUpdateParams;
+import org.opencb.opencga.core.models.job.MinimumRequirements;
 import org.opencb.opencga.core.models.job.ToolInfo;
-import org.opencb.opencga.core.models.job.ToolInfoExecutor;
 import org.opencb.opencga.core.response.QueryType;
 import org.opencb.opencga.core.response.RestResponse;
 import org.opencb.opencga.core.tools.annotations.Tool;
@@ -185,11 +186,11 @@ private RestResponse<Job> create() throws Exception {
             putNestedIfNotEmpty(beanParams, "id", commandOptions.id, true);
             putNestedIfNotEmpty(beanParams, "description", commandOptions.description, true);
             putNestedIfNotEmpty(beanParams, "tool.id", commandOptions.toolId, true);
-            putNestedIfNotEmpty(beanParams, "tool.version", commandOptions.toolVersion, true);
             putNestedIfNotEmpty(beanParams, "tool.description", commandOptions.toolDescription, true);
             putNestedIfNotNull(beanParams, "tool.scope", commandOptions.toolScope, true);
             putNestedIfNotNull(beanParams, "tool.type", commandOptions.toolType, true);
             putNestedIfNotNull(beanParams, "tool.resource", commandOptions.toolResource, true);
+            putNestedIfNotNull(beanParams, "type", commandOptions.type, true);
             putNestedIfNotNull(beanParams, "priority", commandOptions.priority, true);
             putNestedIfNotEmpty(beanParams, "commandLine", commandOptions.commandLine, true);
             putNestedMapIfNotEmpty(beanParams, "params", commandOptions.params, true);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
index 29bca426dfd..81bd3cac9cb 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/executors/WorkflowsCommandExecutor.java
@@ -14,12 +14,12 @@
 import org.opencb.opencga.client.exceptions.ClientException;
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.MinimumRequirements;
 import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
 import org.opencb.opencga.core.models.workflow.Workflow;
 import org.opencb.opencga.core.models.workflow.WorkflowAclEntryList;
 import org.opencb.opencga.core.models.workflow.WorkflowAclUpdateParams;
 import org.opencb.opencga.core.models.workflow.WorkflowCreateParams;
-import org.opencb.opencga.core.models.workflow.WorkflowMinimumRequirements;
 import org.opencb.opencga.core.models.workflow.WorkflowRepository;
 import org.opencb.opencga.core.models.workflow.WorkflowRepositoryParams;
 import org.opencb.opencga.core.models.workflow.WorkflowSystem;
@@ -171,9 +171,9 @@ private RestResponse<Workflow> create() throws Exception {
             putNestedIfNotEmpty(beanParams, "repository.version", commandOptions.repositoryVersion, true);
             putNestedIfNotEmpty(beanParams, "repository.author", commandOptions.repositoryAuthor, true);
             putNestedIfNotEmpty(beanParams, "repository.description", commandOptions.repositoryDescription, true);
-            putNestedIfNotNull(beanParams, "minimumRequirements.cpu", commandOptions.minimumRequirementsCpu, true);
-            putNestedIfNotNull(beanParams, "minimumRequirements.memory", commandOptions.minimumRequirementsMemory, true);
-            putNestedIfNotNull(beanParams, "minimumRequirements.disk", commandOptions.minimumRequirementsDisk, true);
+            putNestedIfNotEmpty(beanParams, "minimumRequirements.cpu", commandOptions.minimumRequirementsCpu, true);
+            putNestedIfNotEmpty(beanParams, "minimumRequirements.memory", commandOptions.minimumRequirementsMemory, true);
+            putNestedIfNotEmpty(beanParams, "minimumRequirements.disk", commandOptions.minimumRequirementsDisk, true);
             putNestedIfNotEmpty(beanParams, "creationDate", commandOptions.creationDate, true);
             putNestedIfNotEmpty(beanParams, "modificationDate", commandOptions.modificationDate, true);
             putNestedMapIfNotEmpty(beanParams, "attributes", commandOptions.attributes, true);
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
index 2e1e733a7d3..bf7f49c32d5 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/JobsCommandOptions.java
@@ -121,9 +121,6 @@ public class CreateCommandOptions {
         @Parameter(names = {"--tool-id"}, description = "Object ID is a mandatory parameter when creating a new one, this ID cannot be changed at the moment.", required = false, arity = 1)
         public String toolId;
     
-        @Parameter(names = {"--tool-version"}, description = "Version of the tool to be executed.", required = false, arity = 1)
-        public String toolVersion;
-    
         @Parameter(names = {"--tool-description"}, description = "Users may provide a description for the entry.", required = false, arity = 1)
         public String toolDescription;
     
@@ -136,6 +133,9 @@ public class CreateCommandOptions {
         @Parameter(names = {"--tool-resource"}, description = "Tool info resource can have the values AUDIT, USER, PROJECT, STUDY, FILE, SAMPLE, JOB, INDIVIDUAL, COHORT, DISEASE_PANEL, FAMILY, CLINICAL_ANALYSIS, INTERPRETATION, VARIANT, ALIGNMENT, CLINICAL, EXPRESSION, RGA and FUNCTIONAL.", required = false, arity = 1)
         public String toolResource;
     
+        @Parameter(names = {"--type"}, description = "Enum param allowed values: NATIVE, WORKFLOW, CUSTOM, WALKER", required = false, arity = 1)
+        public String type;
+    
         @Parameter(names = {"--priority"}, description = "The body web service priority parameter", required = false, arity = 1)
         public String priority;
     
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java
index 4e286527062..fae3079ddd1 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/cli/main/options/WorkflowsCommandOptions.java
@@ -151,14 +151,14 @@ public class CreateCommandOptions {
         @Parameter(names = {"--repository-description"}, description = "The body web service description parameter", required = false, arity = 1)
         public String repositoryDescription;
     
-        @Parameter(names = {"--minimum-requirements-cpu"}, description = "Minimum number of cpu cores required to execute the workflow.", required = false, arity = 1)
-        public Integer minimumRequirementsCpu;
+        @Parameter(names = {"--minimum-requirements-cpu"}, description = "Minimum number of cpu cores required to execute the process.", required = false, arity = 1)
+        public String minimumRequirementsCpu;
     
-        @Parameter(names = {"--minimum-requirements-memory"}, description = "Minimum memory required to execute the workflow (expressed in GB).", required = false, arity = 1)
-        public Integer minimumRequirementsMemory;
+        @Parameter(names = {"--minimum-requirements-memory"}, description = "Minimum memory required to execute the process.", required = false, arity = 1)
+        public String minimumRequirementsMemory;
     
-        @Parameter(names = {"--minimum-requirements-disk"}, description = "Minimum disk required to execute the workflow", required = false, arity = 1)
-        public Integer minimumRequirementsDisk;
+        @Parameter(names = {"--minimum-requirements-disk"}, description = "Minimum disk required to execute the process.", required = false, arity = 1)
+        public String minimumRequirementsDisk;
     
         @Parameter(names = {"--creation-date", "--cd"}, description = "Autogenerated date following the format YYYYMMDDhhmmss containing the date when the entry was first registered.", required = false, arity = 1)
         public String creationDate;
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/AnnotationSetManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/AnnotationSetManager.java
index 22984987b8c..9dea4905ebd 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/AnnotationSetManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/AnnotationSetManager.java
@@ -43,6 +43,7 @@
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.file.FileCreateParams;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.models.study.StudyPermissions;
 import org.opencb.opencga.core.models.study.Variable;
@@ -181,7 +182,7 @@ public OpenCGAResult<Job> loadTsvAnnotations(String studyStr, String variableSet
         jobParams.put("file", path);
         jobParams.put("variableSetId", variableSetId);
         jobParams.put("annotationSetId", annotationSetId);
-        return catalogManager.getJobManager().submit(study.getFqn(), toolId, Enums.Priority.MEDIUM, jobParams, token);
+        return catalogManager.getJobManager().submit(study.getFqn(), JobType.NATIVE, toolId, Enums.Priority.MEDIUM, jobParams, token);
     }
 
     protected <T extends Annotable> void checkUpdateAnnotations(String organizationId, Study study, T entry, ObjectMap parameters,
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
index eee5e4a10f8..d12c6d3886f 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/JobManager.java
@@ -320,6 +320,7 @@ public OpenCGAResult<Job> create(String studyStr, Job job, QueryOptions options,
 
     private void autoCompleteNewJob(String organizationId, Study study, Job job, JwtPayload tokenPayload) throws CatalogException {
         ParamUtils.checkObj(job, "Job");
+        ParamUtils.checkObj(job.getType(), "Job type");
 
         // Auto generate id
         if (StringUtils.isEmpty(job.getId())) {
@@ -381,10 +382,10 @@ private void autoCompleteNewJob(String organizationId, Study study, Job job, Jwt
         } else {
             // We only check input files if the job does not depend on other job that might be creating the necessary files.
             List<File> inputFiles;
-            if (job.getTool().getExternalExecutor() != null && StringUtils.isNotEmpty(job.getTool().getExternalExecutor().getId())) {
-                inputFiles = getWorkflowJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
-            } else {
+            if (job.getType() == JobType.NATIVE) {
                 inputFiles = getJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
+            } else {
+                inputFiles = getWorkflowJobInputFilesFromParams(study.getFqn(), job, tokenPayload.getToken());
             }
             job.setInput(inputFiles);
         }
@@ -538,19 +539,19 @@ public OpenCGAResult<Job> retry(String studyStr, JobRetryParams jobRetry, Enums.
             if (StringUtils.isEmpty(jobDescription)) {
                 jobDescription = "Retry from job '" + jobRetry.getJob() + "'";
             }
-            return submit(studyStr, job.getTool(), priority, params, jobId, jobDescription, jobDependsOn, jobTags, job.getId(),
-                    jobScheduledStartTime, job.isDryRun(), attributes, token);
+            return submit(studyStr, job.getType(), job.getTool(), priority, params, jobId, jobDescription, jobDependsOn, jobTags,
+                    job.getId(), jobScheduledStartTime, job.isDryRun(), attributes, token);
         } else {
             throw new CatalogException("Unable to retry job with status " + job.getInternal().getStatus().getId());
         }
     }
 
-    public OpenCGAResult<Job> submit(String studyStr, String toolId, Enums.Priority priority, Map<String, Object> params, String token)
-            throws CatalogException {
-        return submit(studyStr, toolId, priority, params, null, null, null, null, null, null, false, token);
+    public OpenCGAResult<Job> submit(String studyStr, JobType type, String toolId, Enums.Priority priority, Map<String, Object> params,
+                                     String token) throws CatalogException {
+        return submit(studyStr, type, toolId, priority, params, null, null, null, null, null, null, false, token);
     }
 
-    public OpenCGAResult<Job> submitProject(String projectStr, String toolId, Enums.Priority priority,
+    public OpenCGAResult<Job> submitProject(String projectStr, JobType type, String toolId, Enums.Priority priority,
                                             Map<String, Object> params, String jobId, String jobDescription, List<String> jobDependsOn,
                                             List<String> jobTags, String token) throws CatalogException {
         // Project job
@@ -565,18 +566,20 @@ public OpenCGAResult<Job> submitProject(String projectStr, String toolId, Enums.
         if (studies.isEmpty()) {
             throw new CatalogException("Project '" + projectStr + "' not found!");
         }
-        return submit(studies.get(0), toolId, priority, params, jobId, jobDescription, jobDependsOn, jobTags, null, null, false, token);
+        return submit(studies.get(0), type, toolId, priority, params, jobId, jobDescription, jobDependsOn, jobTags, null, null, false,
+                token);
     }
 
-    public OpenCGAResult<Job> submit(String studyStr, String toolId, Enums.Priority priority, Map<String, Object> params, String jobId,
-                                     String jobDescription, List<String> jobDependsOn, List<String> jobTags, @Nullable String jobParentId,
-                                     @Nullable String scheduledStartTime, Boolean dryRun, String token) throws CatalogException {
-        return submit(studyStr, new ToolInfo().setId(toolId), priority, params, jobId, jobDescription, jobDependsOn, jobTags, jobParentId,
-                scheduledStartTime, dryRun, null, token);
+    public OpenCGAResult<Job> submit(String studyStr, JobType type, String toolId, Enums.Priority priority, Map<String, Object> params,
+                                     String jobId, String jobDescription, List<String> jobDependsOn, List<String> jobTags,
+                                     @Nullable String jobParentId, @Nullable String scheduledStartTime, Boolean dryRun, String token)
+            throws CatalogException {
+        return submit(studyStr, type, new ToolInfo().setId(toolId), priority, params, jobId, jobDescription, jobDependsOn,
+                jobTags, jobParentId, scheduledStartTime, dryRun, null, token);
     }
 
-    public OpenCGAResult<Job> submit(String studyStr, ToolInfo toolInfo, Enums.Priority priority, Map<String, Object> params, String jobId,
-                                     String jobDescription, List<String> jobDependsOn, List<String> jobTags,
+    public OpenCGAResult<Job> submit(String studyStr, JobType type, ToolInfo toolInfo, Enums.Priority priority, Map<String, Object> params,
+                                     String jobId, String jobDescription, List<String> jobDependsOn, List<String> jobTags,
                                      @Nullable String jobParentId, @Nullable String scheduledStartTime, Boolean dryRun,
                                      Map<String, Object> attributes, String token) throws CatalogException {
         JwtPayload tokenPayload = catalogManager.getUserManager().validateToken(token);
@@ -587,6 +590,7 @@ public OpenCGAResult<Job> submit(String studyStr, ToolInfo toolInfo, Enums.Prior
 
         ObjectMap auditParams = new ObjectMap()
                 .append("study", studyStr)
+                .append("type", type)
                 .append("toolInfo", toolInfo)
                 .append("jobPriority", priority)
                 .append("params", params)
@@ -601,6 +605,7 @@ public OpenCGAResult<Job> submit(String studyStr, ToolInfo toolInfo, Enums.Prior
         Job job = new Job();
         job.setId(jobId);
         job.setDescription(jobDescription);
+        job.setType(type);
         job.setTool(toolInfo);
         job.setTags(jobTags);
         job.setStudy(new JobStudyParam(study.getFqn()));
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
index 93d202fa3e7..a9da3de81b8 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/WorkflowManager.java
@@ -32,8 +32,9 @@
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.common.InternalStatus;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
+import org.opencb.opencga.core.models.job.MinimumRequirements;
 import org.opencb.opencga.core.models.job.ToolInfo;
-import org.opencb.opencga.core.models.job.ToolInfoExecutor;
 import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.models.study.StudyPermissions;
 import org.opencb.opencga.core.models.workflow.*;
@@ -191,10 +192,11 @@ public OpenCGAResult<Job> submit(String studyStr, NextFlowRunParams runParams, S
 
         ToolInfo toolInfo = new ToolInfo()
                 .setId(workflow.getId())
-                .setVersion(String.valueOf(workflow.getVersion()))
-                .setDescription(workflow.getDescription())
-                .setExternalExecutor(new ToolInfoExecutor(workflow.getManager().getId().name().toLowerCase(),
-                        workflow.getManager().getVersion()));
+                // Set workflow minimum requirements
+                .setMinimumRequirements(workflow.getMinimumRequirements() != null
+                        ? workflow.getMinimumRequirements()
+                        : configuration.getAnalysis().getWorkflow().getMinRequirements())
+                .setDescription(workflow.getDescription());
 
         Map<String, Object> paramsMap = runParams.toParams();
         paramsMap.putIfAbsent(ParamConstants.STUDY_PARAM, study.getFqn());
@@ -218,8 +220,8 @@ public OpenCGAResult<Job> submit(String studyStr, NextFlowRunParams runParams, S
             jobTags = Collections.emptyList();
         }
 
-        return catalogManager.getJobManager().submit(study.getFqn(), toolInfo, priority, paramsMap, jobId, jobDescription, jobDependsOn,
-                jobTags, null, jobScheduledStartTime, dryRun, Collections.emptyMap(), token);
+        return catalogManager.getJobManager().submit(study.getFqn(), JobType.WORKFLOW, toolInfo, priority, paramsMap, jobId, jobDescription,
+                jobDependsOn, jobTags, null, jobScheduledStartTime, dryRun, Collections.emptyMap(), token);
     }
 
     public OpenCGAResult<Workflow> importWorkflow(String studyStr, WorkflowRepositoryParams repository, QueryOptions options, String token)
@@ -312,7 +314,7 @@ private Workflow downloadWorkflow(WorkflowRepositoryParams repository) throws Ca
         }
 
         Workflow workflow = new Workflow("", "", "", null, new WorkflowSystem(WorkflowSystem.SystemId.NEXTFLOW, ""), new LinkedList<>(),
-                new LinkedList<>(), new WorkflowMinimumRequirements(), false, repository.toWorkflowRepository(), new LinkedList<>(),
+                new LinkedList<>(), new MinimumRequirements(), false, repository.toWorkflowRepository(), new LinkedList<>(),
                 new WorkflowInternal(), TimeUtils.getTime(), TimeUtils.getTime(), new HashMap<>());
         try {
             URL url = new URL(urlStr);
@@ -402,10 +404,10 @@ private void fillWithGitpodManifest(Workflow workflow, String rawline) {
         String value = split[1].replace("\"", "").replace("'", "").trim();
         switch (key) {
             case "executor.cpus":
-                workflow.getMinimumRequirements().setCpu(Integer.valueOf(value));
+                workflow.getMinimumRequirements().setCpu(value);
                 break;
             case "executor.memory":
-                workflow.getMinimumRequirements().setMemory(Integer.valueOf(value.split("\\.")[0]));
+                workflow.getMinimumRequirements().setMemory(value);
                 break;
             default:
                 break;
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/migration/MigrationManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/migration/MigrationManager.java
index 79b4050823b..087669cb1dc 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/migration/MigrationManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/migration/MigrationManager.java
@@ -21,7 +21,6 @@
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.managers.CatalogManager;
 import org.opencb.opencga.core.api.ParamConstants;
-import org.opencb.opencga.core.common.GitRepositoryState;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Configuration;
 import org.opencb.opencga.core.config.storage.StorageConfiguration;
@@ -745,8 +744,7 @@ private MigrationRun run(String organizationId, Class<? extends MigrationTool> r
                         .setCreationDate(TimeUtils.getTime(start))
                         .setCommandLine("opencga-admin.sh")
                         .setParams(params)
-                        .setTool(new ToolInfo(annotation.id(), GitRepositoryState.getInstance().getBuildVersion(), annotation.description(),
-                                Tool.Scope.GLOBAL, null, null))
+                        .setTool(new ToolInfo(annotation.id(), annotation.description(), Tool.Scope.GLOBAL, null, null, null))
                         .setOutDir(outdir.first())
                         .setStderr(stderr.first())
                         .setInternal(new JobInternal()
diff --git a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/CatalogManagerTest.java b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/CatalogManagerTest.java
index 8f0bce1401e..efd524e4db0 100644
--- a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/CatalogManagerTest.java
+++ b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/managers/CatalogManagerTest.java
@@ -700,8 +700,8 @@ public void removeUsersFromStudies() throws CatalogException {
     public void testCreateJob() throws CatalogException {
         String studyId = catalogManager.getStudyManager().searchInOrganization(organizationId, new Query(), null, ownerToken).first().getId();
 
-        catalogManager.getJobManager().submit(studyId, "command-subcommand", null, Collections.emptyMap(), ownerToken);
-        catalogManager.getJobManager().submit(studyId, "command-subcommand2", null, Collections.emptyMap(), ownerToken);
+        catalogManager.getJobManager().submit(studyId, JobType.NATIVE, "command-subcommand", null, Collections.emptyMap(), ownerToken);
+        catalogManager.getJobManager().submit(studyId, JobType.NATIVE, "command-subcommand2", null, Collections.emptyMap(), ownerToken);
 
         catalogManager.getJobManager().create(studyId,
                 new Job().setId("job1").setInternal(new JobInternal(new Enums.ExecutionStatus(Enums.ExecutionStatus.DONE))),
@@ -729,7 +729,7 @@ public void testCreateJob() throws CatalogException {
 
     @Test
     public void testKillJob() throws CatalogException {
-        Job job = catalogManager.getJobManager().submit(studyId, "command-subcommand", null, Collections.emptyMap(), ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyId, JobType.NATIVE, "command-subcommand", null, Collections.emptyMap(), ownerToken).first();
         assertFalse(job.getInternal().isKillJobRequested());
 
         catalogManager.getJobManager().kill(studyFqn, job.getId(), ownerToken);
@@ -737,7 +737,7 @@ public void testKillJob() throws CatalogException {
         assertTrue(job.getInternal().isKillJobRequested());
 
         for (String status : Arrays.asList(Enums.ExecutionStatus.DONE, Enums.ExecutionStatus.ABORTED, Enums.ExecutionStatus.ERROR)) {
-            job = catalogManager.getJobManager().submit(studyId, "command-subcommand", null, Collections.emptyMap(), ownerToken).first();
+            job = catalogManager.getJobManager().submit(studyId, JobType.NATIVE, "command-subcommand", null, Collections.emptyMap(), ownerToken).first();
             catalogManager.getJobManager().update(studyFqn, job.getId(),
                     new ObjectMap(JobDBAdaptor.QueryParams.INTERNAL_STATUS.key(), new Enums.ExecutionStatus(status)),
                     QueryOptions.empty(), ownerToken);
@@ -765,41 +765,41 @@ public void testCreateJobAndReuse() throws CatalogException {
 //                .put("jobs.reuse.tools", "command-subcommand");
 //        String toolId = "command-subcommand";
         String toolId = "variant-index";
-        String job1 = catalogManager.getJobManager().submit(study1, toolId, null, new ObjectMap("key", 1).append("key2", 2), ownerToken).first().getId();
+        String job1 = catalogManager.getJobManager().submit(study1, JobType.NATIVE, toolId, null, new ObjectMap("key", 1).append("key2", 2), ownerToken).first().getId();
 
         // Same params, different order, empty jobId
-        OpenCGAResult<Job> result = catalogManager.getJobManager().submit(study1, toolId, null, new ObjectMap("key2", 2).append("key", 1),
+        OpenCGAResult<Job> result = catalogManager.getJobManager().submit(study1, JobType.NATIVE, toolId, null, new ObjectMap("key2", 2).append("key", 1),
                 "", "", Collections.emptyList(), Collections.emptyList(), null, null, false, ownerToken);
         assertEquals(job1, result.first().getId());
         assertEquals(1, result.getEvents().size());
         assertEquals("reuse", result.getEvents().get(0).getId());
 
         // Same params, different values
-        result = catalogManager.getJobManager().submit(study1, toolId, null, new ObjectMap("key2", 2).append("key", 2), ownerToken);
+        result = catalogManager.getJobManager().submit(study1, JobType.NATIVE, toolId, null, new ObjectMap("key2", 2).append("key", 2), ownerToken);
         assertNotEquals(job1, result.first().getId());
 
         // Same params, but with jobId
-        result = catalogManager.getJobManager().submit(study1, toolId, null, new ObjectMap("key2", 2).append("key", 2), "MyJobId", "",
+        result = catalogManager.getJobManager().submit(study1, JobType.NATIVE, toolId, null, new ObjectMap("key2", 2).append("key", 2), "MyJobId", "",
                 Collections.emptyList(), Collections.emptyList(), null, null, false, ownerToken);
         assertNotEquals(job1, result.first().getId());
         assertEquals("MyJobId", result.first().getId());
 
         // Same params, but with dependencies
-        result = catalogManager.getJobManager().submit(study1, toolId, null, new ObjectMap("key2", 2).append("key", 2), "", "",
+        result = catalogManager.getJobManager().submit(study1, JobType.NATIVE, toolId, null, new ObjectMap("key2", 2).append("key", 2), "", "",
                 Collections.singletonList(job1), Collections.emptyList(), null, null, false, ownerToken);
         assertNotEquals(job1, result.first().getId());
     }
 
     @Test
     public void submitJobWithDependenciesFromDifferentStudies() throws CatalogException {
-        Job first = catalogManager.getJobManager().submit(studyFqn, "command-subcommand", null, Collections.emptyMap(), ownerToken).first();
-        Job second = catalogManager.getJobManager().submit(studyFqn2, "command-subcommand2", null, Collections.emptyMap(), null, "",
+        Job first = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "command-subcommand", null, Collections.emptyMap(), ownerToken).first();
+        Job second = catalogManager.getJobManager().submit(studyFqn2, JobType.NATIVE, "command-subcommand2", null, Collections.emptyMap(), null, "",
                 Collections.singletonList(first.getUuid()), null, null, null, false, ownerToken).first();
         assertEquals(first.getId(), second.getDependsOn().get(0).getId());
 
         thrown.expect(CatalogException.class);
         thrown.expectMessage("not found");
-        catalogManager.getJobManager().submit(studyFqn2, "command-subcommand2", null, Collections.emptyMap(), null, "",
+        catalogManager.getJobManager().submit(studyFqn2, JobType.NATIVE, "command-subcommand2", null, Collections.emptyMap(), null, "",
                 Collections.singletonList(first.getId()), null, null, null, false, ownerToken);
     }
 
@@ -853,7 +853,7 @@ public void testJobsTop() throws CatalogException {
 
     @Test
     public void submitJobOwner() throws CatalogException {
-        OpenCGAResult<Job> job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(),
+        OpenCGAResult<Job> job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(),
                 ownerToken);
 
         assertEquals(1, job.getNumResults());
@@ -862,12 +862,12 @@ public void submitJobOwner() throws CatalogException {
 
     @Test
     public void submitJobWithDependencies() throws CatalogException {
-        Job job1 = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap("param", "file1"), ownerToken).first();
-        Job job2 = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap("param", "file2"), ownerToken).first();
+        Job job1 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap("param", "file1"), ownerToken).first();
+        Job job2 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap("param", "file2"), ownerToken).first();
 
-        Job job3 = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap("param", "file3"), null, null,
+        Job job3 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap("param", "file3"), null, null,
                 Arrays.asList(job1.getId(), job2.getId()), null, null, null, false, ownerToken).first();
-        Job job4 = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap("param", "file4"), null, null,
+        Job job4 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap("param", "file4"), null, null,
                 Arrays.asList(job1.getUuid(), job2.getUuid()), null, null, null, false, ownerToken).first();
 
         assertEquals(2, job3.getDependsOn().size());
@@ -885,7 +885,7 @@ public void submitJobFromAdminsGroup() throws CatalogException {
         catalogManager.getStudyManager().updateGroup(studyFqn, "@admins", ParamUtils.BasicUpdateAction.ADD,
                 new GroupUpdateParams(Collections.singletonList(normalUserId3)), ownerToken);
 
-        OpenCGAResult<Job> job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(),
+        OpenCGAResult<Job> job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(),
                 ownerToken);
 
         assertEquals(1, job.getNumResults());
@@ -903,7 +903,7 @@ public void submitJobWithoutPermissions() throws CatalogException {
                 new StudyAclParams("", ""), ParamUtils.AclAction.SET, ownerToken);
 
         try {
-            catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(), normalToken3);
+            catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(), normalToken3);
             fail("Submission should have failed with a message saying the user does not have EXECUTION permissions");
         } catch (CatalogException e) {
             assertTrue(e.getMessage().contains("Permission denied"));
@@ -925,7 +925,7 @@ public void submitJobWithPermissions() throws CatalogException {
         catalogManager.getStudyManager().updateAcl(studyFqn, normalUserId3,
                 new StudyAclParams(StudyPermissions.Permissions.EXECUTE_JOBS.name(), AuthorizationManager.ROLE_VIEW_ONLY), ParamUtils.AclAction.SET, ownerToken);
 
-        OpenCGAResult<Job> search = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(),
+        OpenCGAResult<Job> search = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(),
                 orgAdminToken2);
         assertEquals(1, search.getNumResults());
         assertEquals(Enums.ExecutionStatus.PENDING, search.first().getInternal().getStatus().getId());
@@ -936,7 +936,7 @@ public void deleteJobTest() throws CatalogException {
         catalogManager.getStudyManager().updateAcl(studyFqn, normalUserId1,
                 new StudyAclParams(StudyPermissions.Permissions.EXECUTE_JOBS.name(), AuthorizationManager.ROLE_VIEW_ONLY), ParamUtils.AclAction.SET, ownerToken);
 
-        OpenCGAResult<Job> search = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(),
+        OpenCGAResult<Job> search = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(),
                 normalToken1);
         assertEquals(1, search.getNumResults());
         assertEquals(Enums.ExecutionStatus.PENDING, search.first().getInternal().getStatus().getId());
@@ -948,7 +948,7 @@ public void deleteJobTest() throws CatalogException {
 
     @Test
     public void visitJob() throws CatalogException {
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(), ownerToken)
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, new ObjectMap(), ownerToken)
                 .first();
 
         Query query = new Query(JobDBAdaptor.QueryParams.VISITED.key(), false);
diff --git a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/migration/MigrationManagerTest.java b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/migration/MigrationManagerTest.java
index b7d6b72f62f..77c3d2f97b3 100644
--- a/opencga-catalog/src/test/java/org/opencb/opencga/catalog/migration/MigrationManagerTest.java
+++ b/opencga-catalog/src/test/java/org/opencb/opencga/catalog/migration/MigrationManagerTest.java
@@ -18,6 +18,7 @@
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.job.Job;
 import org.opencb.opencga.core.models.job.JobReferenceParam;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.migration.MigrationRun;
 import org.opencb.opencga.core.testclassification.duration.MediumTests;
 
@@ -125,7 +126,7 @@ protected void run() throws Exception {
             String fqn = catalogManager.getProjectManager().search(organizationId, new Query(), new QueryOptions(), token).first().getFqn();
             getMigrationRun().getJobs().clear();
 
-            getMigrationRun().addJob(catalogManager.getJobManager().submitProject(fqn, "my-tool", null, Collections.emptyMap(), null, null,
+            getMigrationRun().addJob(catalogManager.getJobManager().submitProject(fqn, JobType.NATIVE, "my-tool", null, Collections.emptyMap(), null, null,
                     null, null, token).first());
         }
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
index 859f37d8e61..ac36608ed45 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/api/FieldConstants.java
@@ -320,13 +320,12 @@ public class FieldConstants {
     public static final String WORKFLOW_SCRIPTS_DESCRIPTION = "List of scripts used by the Workflow.";
     public static final String WORKFLOW_TAGS_DESCRIPTION = "List of tags.";
     public static final String WORKFLOW_VARIABLES_DESCRIPTION = "List of variables accepted by the Workflow.";
-    public static final String WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION = "Minimum requirements to execute the workflow.";
+    public static final String MINIMUM_REQUIREMENTS_DESCRIPTION = "Minimum requirements to execute the process.";
     public static final String WORKFLOW_INTERNAL_DESCRIPTION = "Workflow internal information.";
 
-    public static final String WORKFLOW_MIN_REQUIREMENTS_CPU_DESCRIPTION = "Minimum number of cpu cores required to execute the workflow.";
-    public static final String WORKFLOW_MIN_REQUIREMENTS_MEMORY_DESCRIPTION = "Minimum memory required to execute the workflow"
-            + " (expressed in GB).";
-    public static final String WORKFLOW_MIN_REQUIREMENTS_DISK_DESCRIPTION = "Minimum disk required to execute the workflow";
+    public static final String MIN_REQUIREMENTS_CPU_DESCRIPTION = "Minimum number of cpu cores required to execute the process.";
+    public static final String MIN_REQUIREMENTS_MEMORY_DESCRIPTION = "Minimum memory required to execute the process.";
+    public static final String MIN_REQUIREMENTS_DISK_DESCRIPTION = "Minimum disk required to execute the process.";
 
     public static final String WORKFLOW_SYSTEM_ID_DESCRIPTION = "Workflow system id. Valid values: NEXTFLOW.";
     public static final String WORKFLOW_SYSTEM_VERSION_DESCRIPTION = "Workflow system version to use.";
@@ -397,11 +396,13 @@ public class FieldConstants {
     public static final String EXECUTION_RESULT_START = "Date the execution started.";
     public static final String EXECUTION_RESULT_END = "Date the execution was completed.";
     public static final String EXECUTION_RESULT_STATUS = "Executor status can have the values PENDING, RUNNING, DONE and ERROR.";
+    public static final String EXECUTION_RESULT_DEPENDENCIES = "List of tool dependencies used during the execution.";
     public static final String EXECUTION_RESULT_EXTERNAL_FILES = "List of uris to the external files.";
     public static final String EXECUTION_RESULT_STEPS = "List of ToolStep.";
     public static final String EXECUTION_RESULT_EVENTS = "List of Event.";
 
     //Job
+    public static final String JOB_TYPE = "Job type indicating the origin of the tool that will be run.";
     public static final String JOB_TOOL = "Job tool info.";
     public static final String JOB_USER_ID = "Job user id.";
     public static final String JOB_COMMAND_LINE = "Job command line.";
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/config/Configuration.java b/opencga-core/src/main/java/org/opencb/opencga/core/config/Configuration.java
index 95b7c3c4c6a..3fa4dbcbb25 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/config/Configuration.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/config/Configuration.java
@@ -21,6 +21,7 @@
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.opencb.opencga.core.api.ParamConstants;
+import org.opencb.opencga.core.models.job.MinimumRequirements;
 import org.opencb.opencga.core.models.workflow.WorkflowSystem;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -148,9 +149,9 @@ private static void addDefaultAnalysisWorkflowValues(WorkflowConfiguration workf
                     new WorkflowSystemConfiguration(WorkflowSystem.SystemId.NEXTFLOW.name(), ParamConstants.DEFAULT_MIN_NEXTFLOW_VERSION)));
         }
         if (workflowConfiguration.getMinRequirements() == null) {
-            workflowConfiguration.setMinRequirements(new WorkflowMinRequirementsConfiguration());
+            workflowConfiguration.setMinRequirements(new MinimumRequirements());
         }
-        WorkflowMinRequirementsConfiguration minRequirements = workflowConfiguration.getMinRequirements();
+        MinimumRequirements minRequirements = workflowConfiguration.getMinRequirements();
         if (StringUtils.isEmpty(minRequirements.getCpu())) {
             minRequirements.setCpu("2");
         }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowConfiguration.java b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowConfiguration.java
index 8f0b4cbabd6..68e4e99d01c 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowConfiguration.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowConfiguration.java
@@ -1,19 +1,21 @@
 package org.opencb.opencga.core.config;
 
+import org.opencb.opencga.core.models.job.MinimumRequirements;
+
 import java.util.ArrayList;
 import java.util.List;
 
 public class WorkflowConfiguration {
 
-    private WorkflowMinRequirementsConfiguration minRequirements;
+    private MinimumRequirements minRequirements;
     private List<WorkflowSystemConfiguration> managers;
 
     public WorkflowConfiguration() {
-        this.minRequirements = new WorkflowMinRequirementsConfiguration();
+        this.minRequirements = new MinimumRequirements();
         this.managers = new ArrayList<>();
     }
 
-    public WorkflowConfiguration(WorkflowMinRequirementsConfiguration minRequirements, List<WorkflowSystemConfiguration> managers) {
+    public WorkflowConfiguration(MinimumRequirements minRequirements, List<WorkflowSystemConfiguration> managers) {
         this.minRequirements = minRequirements;
         this.managers = managers;
     }
@@ -27,11 +29,11 @@ public String toString() {
         return sb.toString();
     }
 
-    public WorkflowMinRequirementsConfiguration getMinRequirements() {
+    public MinimumRequirements getMinRequirements() {
         return minRequirements;
     }
 
-    public WorkflowConfiguration setMinRequirements(WorkflowMinRequirementsConfiguration minRequirements) {
+    public WorkflowConfiguration setMinRequirements(MinimumRequirements minRequirements) {
         this.minRequirements = minRequirements;
         return this;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowMinRequirementsConfiguration.java b/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowMinRequirementsConfiguration.java
deleted file mode 100644
index 4a886cd23f9..00000000000
--- a/opencga-core/src/main/java/org/opencb/opencga/core/config/WorkflowMinRequirementsConfiguration.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package org.opencb.opencga.core.config;
-
-public class WorkflowMinRequirementsConfiguration {
-
-    private String cpu;
-    private String memory;
-    private String disk;
-
-    public WorkflowMinRequirementsConfiguration() {
-    }
-
-    public WorkflowMinRequirementsConfiguration(String cpu, String memory, String disk) {
-        this.cpu = cpu;
-        this.memory = memory;
-        this.disk = disk;
-    }
-
-    @Override
-    public String toString() {
-        final StringBuilder sb = new StringBuilder("WorkflowMinRequirementsConfiguration{");
-        sb.append("cpu='").append(cpu).append('\'');
-        sb.append(", memory='").append(memory).append('\'');
-        sb.append(", disk='").append(disk).append('\'');
-        sb.append('}');
-        return sb.toString();
-    }
-
-    public String getCpu() {
-        return cpu;
-    }
-
-    public WorkflowMinRequirementsConfiguration setCpu(String cpu) {
-        this.cpu = cpu;
-        return this;
-    }
-
-    public String getMemory() {
-        return memory;
-    }
-
-    public WorkflowMinRequirementsConfiguration setMemory(String memory) {
-        this.memory = memory;
-        return this;
-    }
-
-    public String getDisk() {
-        return disk;
-    }
-
-    public WorkflowMinRequirementsConfiguration setDisk(String disk) {
-        this.disk = disk;
-        return this;
-    }
-}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/Job.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/Job.java
index 4a1e688c724..0dd2ac420a9 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/Job.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/Job.java
@@ -45,6 +45,9 @@ public class Job extends PrivateStudyUid {
     @DataField(id = "description", defaultValue = "", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
+    @DataField(id = "type", indexed = true, description = FieldConstants.JOB_TYPE)
+    private JobType type;
+
     @DataField(id = "tool", indexed = true, description = FieldConstants.JOB_TOOL)
     private ToolInfo tool;
 
@@ -118,15 +121,16 @@ public class Job extends PrivateStudyUid {
     public Job() {
     }
 
-    public Job(String id, String uuid, String description, ToolInfo tool, String userId, String commandLine, Map<String, Object> params,
-               String creationDate, String modificationDate, Enums.Priority priority, JobInternal internal, File outDir,
-               List<File> input, List<File> output, List<Job> dependsOn, String parentId, String scheduledStartTime, boolean dryRun,
-               List<String> tags, ExecutionResult execution, boolean visited, File stdout, File stderr, int release, JobStudyParam study,
-               Map<String, Object> attributes) {
+    public Job(String id, String uuid, String description, JobType type, ToolInfo tool, String userId, String commandLine,
+               Map<String, Object> params, String creationDate, String modificationDate, Enums.Priority priority, JobInternal internal,
+               File outDir, List<File> input, List<File> output, List<Job> dependsOn, String parentId, String scheduledStartTime,
+               boolean dryRun, List<String> tags, ExecutionResult execution, boolean visited, File stdout, File stderr, int release,
+               JobStudyParam study, Map<String, Object> attributes) {
         this.id = id;
         this.uuid = uuid;
         this.tool = tool;
         this.description = description;
+        this.type = type;
         this.userId = userId;
         this.commandLine = commandLine;
         this.params = params;
@@ -157,6 +161,7 @@ public String toString() {
         sb.append("id='").append(id).append('\'');
         sb.append(", uuid='").append(uuid).append('\'');
         sb.append(", description='").append(description).append('\'');
+        sb.append(", type=").append(type);
         sb.append(", tool=").append(tool);
         sb.append(", userId='").append(userId).append('\'');
         sb.append(", commandLine='").append(commandLine).append('\'');
@@ -226,6 +231,15 @@ public Job setDescription(String description) {
         return this;
     }
 
+    public JobType getType() {
+        return type;
+    }
+
+    public Job setType(JobType type) {
+        this.type = type;
+        return this;
+    }
+
     public ToolInfo getTool() {
         return tool;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobCreateParams.java
index 68382ca25c9..f23a77dc17d 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobCreateParams.java
@@ -32,6 +32,7 @@ public class JobCreateParams {
     private String description;
 
     private ToolInfo tool;
+    private JobType type;
 
     private Enums.Priority priority;
 
@@ -58,12 +59,13 @@ public class JobCreateParams {
     public JobCreateParams() {
     }
 
-    public JobCreateParams(String id, String description, ToolInfo tool, Enums.Priority priority, String commandLine,
+    public JobCreateParams(String id, String description, JobType type, ToolInfo tool, Enums.Priority priority, String commandLine,
                            Map<String, Object> params, String creationDate, String modificationDate, JobInternal internal, TinyFile outDir,
                            List<TinyFile> input, List<TinyFile> output, List<String> tags, ExecutionResult result, TinyFile stdout,
                            TinyFile stderr, Map<String, Object> attributes) {
         this.id = id;
         this.description = description;
+        this.type = type;
         this.tool = tool;
         this.priority = priority;
         this.commandLine = commandLine;
@@ -82,7 +84,7 @@ public JobCreateParams(String id, String description, ToolInfo tool, Enums.Prior
     }
 
     public static JobCreateParams of(Job job) {
-        return new JobCreateParams(job.getId(), job.getDescription(), job.getTool(), job.getPriority(), job.getCommandLine(),
+        return new JobCreateParams(job.getId(), job.getDescription(), job.getType(), job.getTool(), job.getPriority(), job.getCommandLine(),
                 job.getParams(), job.getCreationDate(), job.getModificationDate(),
                 job.getInternal() != null ? new JobInternal(job.getInternal().getStatus()) : null, TinyFile.of(job.getOutDir()),
                 job.getInput() != null ? job.getInput().stream().map(TinyFile::of).collect(Collectors.toList()) : Collections.emptyList(),
@@ -95,6 +97,7 @@ public String toString() {
         final StringBuilder sb = new StringBuilder("JobCreateParams{");
         sb.append("id='").append(id).append('\'');
         sb.append(", description='").append(description).append('\'');
+        sb.append(", type=").append(type);
         sb.append(", tool=").append(tool);
         sb.append(", priority=").append(priority);
         sb.append(", commandLine='").append(commandLine).append('\'');
@@ -133,6 +136,15 @@ public JobCreateParams setDescription(String description) {
         return this;
     }
 
+    public JobType getType() {
+        return type;
+    }
+
+    public JobCreateParams setType(JobType type) {
+        this.type = type;
+        return this;
+    }
+
     public ToolInfo getTool() {
         return tool;
     }
@@ -269,7 +281,8 @@ public JobCreateParams setAttributes(Map<String, Object> attributes) {
     }
 
     public Job toJob() {
-        return new Job(id, null, description, tool, null, commandLine, params, creationDate, null, priority,
+        return new Job(id, null, description, type, tool, null, commandLine, params, creationDate, null,
+                priority,
                 internal != null ? new org.opencb.opencga.core.models.job.JobInternal(internal.getStatus()) : null,
                 outDir != null ? outDir.toFile() : null,
                 getInput() != null ? getInput().stream().map(TinyFile::toFile).collect(Collectors.toList()) : Collections.emptyList(),
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobType.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobType.java
new file mode 100644
index 00000000000..37781538582
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/JobType.java
@@ -0,0 +1,8 @@
+package org.opencb.opencga.core.models.job;
+
+public enum JobType {
+    NATIVE,
+    WORKFLOW,
+    CUSTOM,
+    WALKER
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/MinimumRequirements.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/MinimumRequirements.java
new file mode 100644
index 00000000000..e0c8089e110
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/MinimumRequirements.java
@@ -0,0 +1,62 @@
+package org.opencb.opencga.core.models.job;
+
+import org.opencb.commons.annotations.DataField;
+import org.opencb.opencga.core.api.FieldConstants;
+
+public class MinimumRequirements {
+
+    @DataField(id = "cpu", description = FieldConstants.MIN_REQUIREMENTS_CPU_DESCRIPTION)
+    private String cpu;
+
+    @DataField(id = "memory", description = FieldConstants.MIN_REQUIREMENTS_MEMORY_DESCRIPTION)
+    private String memory;
+
+    @DataField(id = "disk", description = FieldConstants.MIN_REQUIREMENTS_DISK_DESCRIPTION)
+    private String disk;
+
+    public MinimumRequirements() {
+    }
+
+    public MinimumRequirements(String cpu, String memory, String disk) {
+        this.cpu = cpu;
+        this.memory = memory;
+        this.disk = disk;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("WorkflowMinimumRequirements{");
+        sb.append("cpu='").append(cpu).append('\'');
+        sb.append(", memory='").append(memory).append('\'');
+        sb.append(", disk='").append(disk).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getCpu() {
+        return cpu;
+    }
+
+    public MinimumRequirements setCpu(String cpu) {
+        this.cpu = cpu;
+        return this;
+    }
+
+    public String getMemory() {
+        return memory;
+    }
+
+    public MinimumRequirements setMemory(String memory) {
+        this.memory = memory;
+        return this;
+    }
+
+    public String getDisk() {
+        return disk;
+    }
+
+    public MinimumRequirements setDisk(String disk) {
+        this.disk = disk;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
index 6026ca60132..c1abd49f1b4 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/job/ToolInfo.java
@@ -29,9 +29,6 @@ public class ToolInfo {
             description = FieldConstants.GENERIC_ID_DESCRIPTION)
     private String id;
 
-    @DataField(id = "version", description = FieldConstants.TOOL_INFO_VERSION_DESCRIPTION)
-    private String version;
-
     @DataField(id = "description", description = FieldConstants.GENERIC_DESCRIPTION_DESCRIPTION)
     private String description;
 
@@ -44,38 +41,31 @@ public class ToolInfo {
     @DataField(id = "resource", description = FieldConstants.TOOL_INFO_RESOURCE_DESCRIPTION)
     private Enums.Resource resource;
 
-    @DataField(id = "externalExecutor", since = "3.3.0", description = FieldConstants.TOOL_INFO_EXTERNAL_EXECUTOR_DESCRIPTION)
-    private ToolInfoExecutor externalExecutor;
-
+    @DataField(id = "minimumRequirements", description = FieldConstants.MINIMUM_REQUIREMENTS_DESCRIPTION)
+    private MinimumRequirements minimumRequirements;
 
     public ToolInfo() {
     }
 
-    public ToolInfo(String id, String version, String description, Scope scope, Type type, Enums.Resource resource) {
-        this(id, version, description, scope, type, resource, null);
-    }
-
-    public ToolInfo(String id, String version, String description, Scope scope, Type type, Enums.Resource resource,
-                    ToolInfoExecutor externalExecutor) {
+    public ToolInfo(String id, String description, Scope scope, Type type, Enums.Resource resource,
+                    MinimumRequirements minimumRequirements) {
         this.id = id;
-        this.version = version;
         this.description = description;
         this.scope = scope;
         this.type = type;
         this.resource = resource;
-        this.externalExecutor = externalExecutor;
+        this.minimumRequirements = minimumRequirements;
     }
 
     @Override
     public String toString() {
         final StringBuilder sb = new StringBuilder("ToolInfo{");
         sb.append("id='").append(id).append('\'');
-        sb.append(", version='").append(version).append('\'');
         sb.append(", description='").append(description).append('\'');
         sb.append(", scope=").append(scope);
         sb.append(", type=").append(type);
         sb.append(", resource=").append(resource);
-        sb.append(", externalExecutor=").append(externalExecutor);
+        sb.append(", minimumRequirements=").append(minimumRequirements);
         sb.append('}');
         return sb.toString();
     }
@@ -89,15 +79,6 @@ public ToolInfo setId(String id) {
         return this;
     }
 
-    public String getVersion() {
-        return version;
-    }
-
-    public ToolInfo setVersion(String version) {
-        this.version = version;
-        return this;
-    }
-
     public String getDescription() {
         return description;
     }
@@ -134,12 +115,12 @@ public ToolInfo setResource(Enums.Resource resource) {
         return this;
     }
 
-    public ToolInfoExecutor getExternalExecutor() {
-        return externalExecutor;
+    public MinimumRequirements getMinimumRequirements() {
+        return minimumRequirements;
     }
 
-    public ToolInfo setExternalExecutor(ToolInfoExecutor externalExecutor) {
-        this.externalExecutor = externalExecutor;
+    public ToolInfo setMinimumRequirements(MinimumRequirements minimumRequirements) {
+        this.minimumRequirements = minimumRequirements;
         return this;
     }
 }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
index 4728c6ad395..f10445b374b 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/Workflow.java
@@ -4,6 +4,7 @@
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
 import org.opencb.opencga.core.models.PrivateStudyUid;
+import org.opencb.opencga.core.models.job.MinimumRequirements;
 
 import java.util.List;
 import java.util.Map;
@@ -37,8 +38,8 @@ public class Workflow extends PrivateStudyUid {
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
     private List<WorkflowVariable> variables;
 
-    @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
-    private WorkflowMinimumRequirements minimumRequirements;
+    @DataField(id = "minimumRequirements", description = FieldConstants.MINIMUM_REQUIREMENTS_DESCRIPTION)
+    private MinimumRequirements minimumRequirements;
 
     @DataField(id = "draft", description = FieldConstants.WORKFLOW_DRAFT_DESCRIPTION)
     private boolean draft;
@@ -78,7 +79,7 @@ public Workflow() {
     }
 
     public Workflow(String id, String name, String description, Type type, WorkflowSystem manager, List<String> tags,
-                    List<WorkflowVariable> variables, WorkflowMinimumRequirements minimumRequirements, boolean draft,
+                    List<WorkflowVariable> variables, MinimumRequirements minimumRequirements, boolean draft,
                     WorkflowRepository repository, List<WorkflowScript> scripts, WorkflowInternal internal, String creationDate,
                     String modificationDate, Map<String, Object> attributes) {
         this.id = id;
@@ -247,11 +248,11 @@ public Workflow setVariables(List<WorkflowVariable> variables) {
         return this;
     }
 
-    public WorkflowMinimumRequirements getMinimumRequirements() {
+    public MinimumRequirements getMinimumRequirements() {
         return minimumRequirements;
     }
 
-    public Workflow setMinimumRequirements(WorkflowMinimumRequirements minimumRequirements) {
+    public Workflow setMinimumRequirements(MinimumRequirements minimumRequirements) {
         this.minimumRequirements = minimumRequirements;
         return this;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
index a0cde6d36e8..93e3c84a46b 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowCreateParams.java
@@ -2,6 +2,7 @@
 
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
+import org.opencb.opencga.core.models.job.MinimumRequirements;
 
 import java.util.List;
 import java.util.Map;
@@ -36,8 +37,8 @@ public class WorkflowCreateParams {
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
     private List<WorkflowVariable> variables;
 
-    @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
-    private WorkflowMinimumRequirements minimumRequirements;
+    @DataField(id = "minimumRequirements", description = FieldConstants.MINIMUM_REQUIREMENTS_DESCRIPTION)
+    private MinimumRequirements minimumRequirements;
 
     @DataField(id = "scripts", description = FieldConstants.WORKFLOW_SCRIPTS_DESCRIPTION)
     private List<WorkflowScript> scripts;
@@ -56,7 +57,7 @@ public WorkflowCreateParams() {
 
     public WorkflowCreateParams(String id, String name, String description, WorkflowSystem manager, Workflow.Type type, List<String> tags,
                                 boolean draft, WorkflowRepository repository, List<WorkflowVariable> variables,
-                                WorkflowMinimumRequirements minimumRequirements, List<WorkflowScript> scripts, String creationDate,
+                                MinimumRequirements minimumRequirements, List<WorkflowScript> scripts, String creationDate,
                                 String modificationDate, Map<String, Object> attributes) {
         this.id = id;
         this.name = name;
@@ -181,11 +182,11 @@ public WorkflowCreateParams setVariables(List<WorkflowVariable> variables) {
         return this;
     }
 
-    public WorkflowMinimumRequirements getMinimumRequirements() {
+    public MinimumRequirements getMinimumRequirements() {
         return minimumRequirements;
     }
 
-    public WorkflowCreateParams setMinimumRequirements(WorkflowMinimumRequirements minimumRequirements) {
+    public WorkflowCreateParams setMinimumRequirements(MinimumRequirements minimumRequirements) {
         this.minimumRequirements = minimumRequirements;
         return this;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
deleted file mode 100644
index 6f045ff3ce5..00000000000
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowMinimumRequirements.java
+++ /dev/null
@@ -1,62 +0,0 @@
-package org.opencb.opencga.core.models.workflow;
-
-import org.opencb.commons.annotations.DataField;
-import org.opencb.opencga.core.api.FieldConstants;
-
-public class WorkflowMinimumRequirements {
-
-    @DataField(id = "cpu", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_CPU_DESCRIPTION)
-    private Integer cpu;
-
-    @DataField(id = "memory", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_MEMORY_DESCRIPTION)
-    private Integer memory;
-
-    @DataField(id = "disk", description = FieldConstants.WORKFLOW_MIN_REQUIREMENTS_DISK_DESCRIPTION)
-    private Integer disk;
-
-    public WorkflowMinimumRequirements() {
-    }
-
-    public WorkflowMinimumRequirements(Integer cpu, Integer memory, Integer disk) {
-        this.cpu = cpu;
-        this.memory = memory;
-        this.disk = disk;
-    }
-
-    @Override
-    public String toString() {
-        final StringBuilder sb = new StringBuilder("WorkflowMinimumRequirements{");
-        sb.append("cpu='").append(cpu).append('\'');
-        sb.append(", memory='").append(memory).append('\'');
-        sb.append(", disk='").append(disk).append('\'');
-        sb.append('}');
-        return sb.toString();
-    }
-
-    public Integer getCpu() {
-        return cpu;
-    }
-
-    public WorkflowMinimumRequirements setCpu(Integer cpu) {
-        this.cpu = cpu;
-        return this;
-    }
-
-    public Integer getMemory() {
-        return memory;
-    }
-
-    public WorkflowMinimumRequirements setMemory(Integer memory) {
-        this.memory = memory;
-        return this;
-    }
-
-    public Integer getDisk() {
-        return disk;
-    }
-
-    public WorkflowMinimumRequirements setDisk(Integer disk) {
-        this.disk = disk;
-        return this;
-    }
-}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
index ccd88bcb29e..3097d16d75a 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/models/workflow/WorkflowUpdateParams.java
@@ -2,6 +2,7 @@
 
 import org.opencb.commons.annotations.DataField;
 import org.opencb.opencga.core.api.FieldConstants;
+import org.opencb.opencga.core.models.job.MinimumRequirements;
 
 import java.util.List;
 import java.util.Map;
@@ -35,8 +36,8 @@ public class WorkflowUpdateParams {
     @DataField(id = "variables", description = FieldConstants.WORKFLOW_VARIABLES_DESCRIPTION)
     private List<WorkflowVariable> variables;
 
-    @DataField(id = "minimumRequirements", description = FieldConstants.WORKFLOW_MINIMUM_REQUIREMENTS_DESCRIPTION)
-    private WorkflowMinimumRequirements minimumRequirements;
+    @DataField(id = "minimumRequirements", description = FieldConstants.MINIMUM_REQUIREMENTS_DESCRIPTION)
+    private MinimumRequirements minimumRequirements;
 
     @DataField(id = "creationDate", indexed = true, description = FieldConstants.GENERIC_CREATION_DATE_DESCRIPTION)
     private String creationDate;
@@ -52,7 +53,7 @@ public WorkflowUpdateParams() {
 
     public WorkflowUpdateParams(String name, String description, WorkflowSystem manager, Workflow.Type type, List<String> tags,
                                 boolean draft, WorkflowRepository repository, List<WorkflowScript> scripts,
-                                List<WorkflowVariable> variables, WorkflowMinimumRequirements minimumRequirements, String creationDate,
+                                List<WorkflowVariable> variables, MinimumRequirements minimumRequirements, String creationDate,
                                 String modificationDate, Map<String, Object> attributes) {
         this.name = name;
         this.description = description;
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/tools/ToolDependency.java b/opencga-core/src/main/java/org/opencb/opencga/core/tools/ToolDependency.java
new file mode 100644
index 00000000000..df5f07d653a
--- /dev/null
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/tools/ToolDependency.java
@@ -0,0 +1,54 @@
+package org.opencb.opencga.core.tools;
+
+public class ToolDependency {
+
+    private String id;
+    private String version;
+    private String commit;
+
+    public ToolDependency() {
+    }
+
+    public ToolDependency(String id, String version, String commit) {
+        this.id = id;
+        this.version = version;
+        this.commit = commit;
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder("ToolDependency{");
+        sb.append("id='").append(id).append('\'');
+        sb.append(", version='").append(version).append('\'');
+        sb.append(", commit='").append(commit).append('\'');
+        sb.append('}');
+        return sb.toString();
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public ToolDependency setId(String id) {
+        this.id = id;
+        return this;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public ToolDependency setVersion(String version) {
+        this.version = version;
+        return this;
+    }
+
+    public String getCommit() {
+        return commit;
+    }
+
+    public ToolDependency setCommit(String commit) {
+        this.commit = commit;
+        return this;
+    }
+}
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResult.java b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResult.java
index 3d73c2e81dd..412d1695f88 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResult.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResult.java
@@ -20,6 +20,7 @@
 import org.opencb.commons.datastore.core.Event;
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.opencga.core.api.FieldConstants;
+import org.opencb.opencga.core.tools.ToolDependency;
 
 import java.net.URI;
 import java.util.Date;
@@ -49,6 +50,9 @@ public class ExecutionResult {
             description = FieldConstants.EXECUTION_RESULT_STATUS)
     private Status status;
 
+    @DataField(id = "dependencies", description = FieldConstants.EXECUTION_RESULT_DEPENDENCIES)
+    private List<ToolDependency> dependencies;
+
     @DataField(id = "externalFiles", indexed = true,
             description = FieldConstants.EXECUTION_RESULT_EXTERNAL_FILES)
     private List<URI> externalFiles;
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
index 8f367522f10..caa63a6e8e4 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
@@ -88,7 +88,6 @@
 import org.opencb.opencga.catalog.utils.ParamUtils;
 import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.common.ExceptionUtils;
-import org.opencb.opencga.core.common.GitRepositoryState;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Execution;
 import org.opencb.opencga.core.config.storage.StorageConfiguration;
@@ -544,7 +543,7 @@ protected int checkPendingJob(Job job) {
         CatalogFqn catalogFqn = CatalogFqn.extractFqnFromStudyFqn(job.getStudy().getId());
         String organizationId = catalogFqn.getOrganizationId();
 
-        String toolId = ToolFactory.getToolId(job.getTool());
+        String toolId = ToolFactory.getToolId(job.getType(), job.getTool());
         if (StringUtils.isEmpty(toolId)) {
             return abortJob(job, "Tool id '" + toolId + "' not found.");
         }
@@ -561,7 +560,7 @@ protected int checkPendingJob(Job job) {
 
         Tool tool;
         try {
-            tool = new ToolFactory().getTool(job.getTool(), packages);
+            tool = new ToolFactory().getTool(job.getType(), job.getTool(), packages);
         } catch (Exception e) {
             logger.error(e.getMessage(), e);
             return abortJob(job, "Tool " + toolId + " not found", e);
@@ -648,10 +647,6 @@ protected int checkPendingJob(Job job) {
         String shadedCommandLine = commandLine + " " + ParamConstants.OPENCGA_TOKEN_CLI_PARAM + " " + REDACTED_TOKEN;
 
         updateParams.setCommandLine(shadedCommandLine);
-        if (job.getTool().getExternalExecutor() == null || StringUtils.isEmpty(job.getTool().getExternalExecutor().getId())) {
-            job.getTool().setVersion(GitRepositoryState.getInstance().getBuildVersion());
-            updateParams.setTool(job.getTool());
-        }
 
         logger.info("Updating job {} from {} to {}", job.getId(), Enums.ExecutionStatus.PENDING, Enums.ExecutionStatus.QUEUED);
         updateParams.setInternal(new JobInternal(new Enums.ExecutionStatus(Enums.ExecutionStatus.QUEUED)));
@@ -677,9 +672,6 @@ protected int checkPendingJob(Job job) {
     }
 
     private void updateToolInfoInformation(ToolInfo toolInfo, Tool tool) {
-        if (StringUtils.isEmpty(toolInfo.getVersion())) {
-            toolInfo.setVersion(GitRepositoryState.getInstance().getBuildVersion());
-        }
         if (StringUtils.isEmpty(toolInfo.getDescription())) {
             toolInfo.setDescription(tool.description());
         }
@@ -693,7 +685,7 @@ private boolean killSignalSent(Job job) {
     }
 
     protected void checkToolExecutionPermission(String organizationId, Job job) throws Exception {
-        Tool tool = new ToolFactory().getTool(job.getTool(), packages);
+        Tool tool = new ToolFactory().getTool(job.getType(), job.getTool(), packages);
 
         AuthorizationManager authorizationManager = catalogManager.getAuthorizationManager();
         String user = job.getUserId();
@@ -865,7 +857,7 @@ private File getValidDefaultOutDir(String organizationId, Job job) throws Catalo
     }
 
     public static String buildCli(String internalCli, Job job) {
-        String toolId = ToolFactory.getToolId(job.getTool());
+        String toolId = ToolFactory.getToolId(job.getType(), job.getTool());
         String internalCommand = TOOL_CLI_MAP.get(toolId);
         if (StringUtils.isEmpty(internalCommand) || job.isDryRun()) {
             ObjectMap params = new ObjectMap()
diff --git a/opencga-master/src/test/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemonTest.java b/opencga-master/src/test/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemonTest.java
index 9d2de1bdb42..18fae2390f5 100644
--- a/opencga-master/src/test/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemonTest.java
+++ b/opencga-master/src/test/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemonTest.java
@@ -42,10 +42,7 @@
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.file.FileContent;
 import org.opencb.opencga.core.models.file.FileStatus;
-import org.opencb.opencga.core.models.job.Job;
-import org.opencb.opencga.core.models.job.JobInternal;
-import org.opencb.opencga.core.models.job.JobInternalWebhook;
-import org.opencb.opencga.core.models.job.JobPermissions;
+import org.opencb.opencga.core.models.job.*;
 import org.opencb.opencga.core.models.study.GroupUpdateParams;
 import org.opencb.opencga.core.models.study.StudyNotification;
 import org.opencb.opencga.core.models.study.StudyUpdateParams;
@@ -142,7 +139,7 @@ public void testBuildCli() {
     @Test
     public void testCreateDefaultOutDir() throws Exception {
         HashMap<String, Object> params = new HashMap<>();
-        String jobId = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
+        String jobId = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
 
         daemon.checkPendingJobs(organizationIds);
 
@@ -157,7 +154,7 @@ public void testWebhookNotification() throws Exception {
                 .setNotification(new StudyNotification(new URL("https://ptsv2.com/t/dgogf-1581523512/post"))), null, ownerToken);
 
         HashMap<String, Object> params = new HashMap<>();
-        String jobId = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
+        String jobId = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
 
         daemon.checkPendingJobs(organizationIds);
         // We sleep because there must be a thread sending notifying to the webhook url.
@@ -173,7 +170,7 @@ public void testWebhookNotification() throws Exception {
     public void testCreateOutDir() throws Exception {
         HashMap<String, Object> params = new HashMap<>();
         params.put("outdir", "outputDir/");
-        String jobId = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
+        String jobId = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
 
         daemon.checkPendingJobs(organizationIds);
 
@@ -191,7 +188,7 @@ public void testUseEmptyDirectory() throws Exception {
 
         HashMap<String, Object> params = new HashMap<>();
         params.put("outdir", "outputDir/");
-        String jobId = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params,
+        String jobId = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params,
                 ownerToken).first().getId();
 
         daemon.checkPendingJobs(organizationIds);
@@ -205,7 +202,7 @@ public void testUseEmptyDirectory() throws Exception {
     public void testNotEmptyOutDir() throws Exception {
         HashMap<String, Object> params = new HashMap<>();
         params.put("outdir", "data/");
-        String jobId = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
+        String jobId = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
 
         daemon.checkPendingJobs(organizationIds);
 
@@ -219,7 +216,7 @@ public void testNotEmptyOutDir() throws Exception {
     @Test
     public void dryRunExecutionTest() throws Exception {
         ObjectMap params = new ObjectMap();
-        String jobId1 = catalogManager.getJobManager().submit(studyFqn, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
+        String jobId1 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
                 params, "job1", "", null, null, null, null, true, ownerToken).first().getId();
         daemon.checkJobs();
         Job job = catalogManager.getJobManager().get(studyFqn, jobId1, null, ownerToken).first();
@@ -250,13 +247,13 @@ public void testProjectScopeTaskAndScheduler() throws Exception {
                 new GroupUpdateParams(Collections.singletonList(normalUserId3)), ownerToken);
 
         HashMap<String, Object> params = new HashMap<>();
-        String jobId1 = catalogManager.getJobManager().submit(studyFqn, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
+        String jobId1 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
                 params, "job1", "", null, null, null, null, false, normalToken2).first().getId();
-        String jobId2 = catalogManager.getJobManager().submit(studyFqn, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
+        String jobId2 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
                 params, "job2", "", null, null, null, null, false, orgAdminToken1).first().getId();
-        String jobId3 = catalogManager.getJobManager().submit(studyFqn, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
+        String jobId3 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
                 params, "job3", "", null, null, null, null, false, ownerToken).first().getId();
-        String jobId4 = catalogManager.getJobManager().submit(studyFqn, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
+        String jobId4 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, VariantAnnotationIndexOperationTool.ID, Enums.Priority.MEDIUM,
                 params, "job4", "", null, null, null, null, false, normalToken3).first().getId();
 
         daemon.checkJobs();
@@ -355,8 +352,8 @@ public void testProjectScopeTaskAndScheduler() throws Exception {
     @Test
     public void testDependsOnJobs() throws Exception {
         HashMap<String, Object> params = new HashMap<>();
-        String job1 = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
-        String job2 = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params, null, null,
+        String job1 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first().getId();
+        String job2 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, null, null,
                 Collections.singletonList(job1), null, null, null, false, ownerToken).first().getId();
 
         daemon.checkPendingJobs(organizationIds);
@@ -385,7 +382,7 @@ public void testDependsOnJobs() throws Exception {
                 .setInternal(new JobInternal(new Enums.ExecutionStatus(Enums.ExecutionStatus.DONE))), QueryOptions.empty(), ownerToken);
 
         // And create a new job to simulate a normal successfully dependency
-        String job3 = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params, null, null,
+        String job3 = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, null, null,
                 Collections.singletonList(job1), null, null, null, false, ownerToken).first().getId();
         daemon.checkPendingJobs(organizationIds);
 
@@ -397,8 +394,8 @@ public void testDependsOnJobs() throws Exception {
     @Test
     public void testDependsOnMultiStudy() throws Exception {
         HashMap<String, Object> params = new HashMap<>();
-        Job firstJob = catalogManager.getJobManager().submit(studyFqn, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first();
-        Job job = catalogManager.getJobManager().submit(studyFqn2, "files-delete", Enums.Priority.MEDIUM, params, null, null,
+        Job firstJob = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyFqn2, JobType.NATIVE, "files-delete", Enums.Priority.MEDIUM, params, null, null,
                 Collections.singletonList(firstJob.getUuid()), null, null, null, false, ownerToken).first();
         assertEquals(1, job.getDependsOn().size());
         assertEquals(firstJob.getId(), job.getDependsOn().get(0).getId());
@@ -416,7 +413,7 @@ public void testRunJob() throws Exception {
         params.put(ExecutionDaemon.OUTDIR_PARAM, "outDir");
         org.opencb.opencga.core.models.file.File inputFile = catalogManager.getFileManager().get(studyFqn, testFile1, null, ownerToken).first();
         params.put("myFile", inputFile.getPath());
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
         String jobId = job.getId();
 
         daemon.checkJobs();
@@ -446,7 +443,7 @@ public void testCheckLogs() throws Exception {
         params.put(ExecutionDaemon.OUTDIR_PARAM, "outDir");
         org.opencb.opencga.core.models.file.File inputFile = catalogManager.getFileManager().get(studyFqn, testFile1, null, ownerToken).first();
         params.put("myFile", inputFile.getPath());
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
         String jobId = job.getId();
 
         daemon.checkJobs();
@@ -481,7 +478,7 @@ public void testCheckLogsNoPermissions() throws Exception {
         params.put(ExecutionDaemon.OUTDIR_PARAM, "outDir");
         org.opencb.opencga.core.models.file.File inputFile = catalogManager.getFileManager().get(studyFqn, testFile1, null, ownerToken).first();
         params.put("myFile", inputFile.getPath());
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
         String jobId = job.getId();
 
         catalogManager.getJobManager().updateAcl(studyFqn, Collections.singletonList(jobId), normalUserId2,
@@ -517,7 +514,7 @@ public void testRegisterFilesSuccessfully() throws Exception {
 //        params.put(ExecutionDaemon.OUTDIR_PARAM, "outDir");
         org.opencb.opencga.core.models.file.File inputFile = catalogManager.getFileManager().get(studyFqn, testFile1, null, ownerToken).first();
         params.put("myFile", inputFile.getPath());
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
         String jobId = job.getId();
 
         daemon.checkJobs();
@@ -600,7 +597,7 @@ public void scheduledJobTest() throws CatalogException, InterruptedException {
         date.setTime(date.getTime() + 2000);
         String scheduledTime = TimeUtils.getTime(date);
         System.out.println("Scheduled time: " + scheduledTime);
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, params, null, null, null,
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, params, null, null, null,
                 null, null, scheduledTime, null, ownerToken).first();
 
         daemon.checkJobs();
@@ -618,7 +615,7 @@ public void scheduledJobTest() throws CatalogException, InterruptedException {
     public void testRunJobFail() throws Exception {
         HashMap<String, Object> params = new HashMap<>();
         params.put(ExecutionDaemon.OUTDIR_PARAM, "outputDir/");
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
         String jobId = job.getId();
 
         daemon.checkJobs();
@@ -642,7 +639,7 @@ public void testRunJobFail() throws Exception {
     public void testRunJobFailMissingExecutionResult() throws Exception {
         HashMap<String, Object> params = new HashMap<>();
         params.put(ExecutionDaemon.OUTDIR_PARAM, "outputDir/");
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
         String jobId = job.getId();
 
         daemon.checkJobs();
@@ -665,7 +662,7 @@ public void testRunJobFailMissingExecutionResult() throws Exception {
     public void registerMalformedVcfFromExecutedJobTest() throws CatalogException {
         HashMap<String, Object> params = new HashMap<>();
         params.put(ExecutionDaemon.OUTDIR_PARAM, "outputDir/");
-        Job job = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
+        Job job = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.MEDIUM, params, ownerToken).first();
         String jobId = job.getId();
 
         daemon.checkJobs();
diff --git a/opencga-master/src/test/java/org/opencb/opencga/master/monitor/models/PrivateJobUpdateParamsTest.java b/opencga-master/src/test/java/org/opencb/opencga/master/monitor/models/PrivateJobUpdateParamsTest.java
index f58c461736c..1b0249a19ad 100644
--- a/opencga-master/src/test/java/org/opencb/opencga/master/monitor/models/PrivateJobUpdateParamsTest.java
+++ b/opencga-master/src/test/java/org/opencb/opencga/master/monitor/models/PrivateJobUpdateParamsTest.java
@@ -27,6 +27,7 @@
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.job.Job;
 import org.opencb.opencga.core.models.job.JobStudyParam;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.testclassification.duration.MediumTests;
 
@@ -66,7 +67,7 @@ public void test() throws JsonProcessingException {
 
     @Test
     public void updateJobInformation() throws CatalogException {
-        OpenCGAResult<Job> jobResult = catalogManager.getJobManager().submit(studyFqn, "variant-index", Enums.Priority.HIGH,
+        OpenCGAResult<Job> jobResult = catalogManager.getJobManager().submit(studyFqn, JobType.NATIVE, "variant-index", Enums.Priority.HIGH,
                 new HashMap<>(), ownerToken);
 
         PrivateJobUpdateParams updateParams = new PrivateJobUpdateParams().setCommandLine("myCommandLine");
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/FileWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/FileWSServer.java
index 01be67e5a16..5da62470e0d 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/FileWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/FileWSServer.java
@@ -35,6 +35,7 @@
 import org.opencb.opencga.core.models.common.TsvAnnotationParams;
 import org.opencb.opencga.core.models.file.*;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.response.OpenCGAResult;
 import org.opencb.opencga.core.tools.annotations.*;
 
@@ -103,7 +104,7 @@ public Response downloadAndRegister(
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String studyStr,
             @ApiParam(name = "body", value = "Fetch parameters", required = true) FileFetch fetchParams) {
-        return submitJob(FetchAndRegisterTask.ID, studyStr, fetchParams, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(studyStr, JobType.NATIVE, FetchAndRegisterTask.ID, fetchParams, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
@@ -716,7 +717,7 @@ public Response postlink(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(name = "body", value = "File parameters", required = true) PostLinkToolParams params) {
-        return submitJob(PostLinkSampleAssociation.ID, studyStr, params, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(studyStr, JobType.NATIVE, PostLinkSampleAssociation.ID, params, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -732,7 +733,7 @@ public Response linkAsync(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(name = "body", value = "File parameters", required = true) FileLinkToolParams params) {
-        return submitJob(FileLinkTask.ID, studyStr, params, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(studyStr, JobType.NATIVE, FileLinkTask.ID, params, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @DELETE
@@ -747,7 +748,7 @@ public Response unlink(
             ObjectMap params = new ObjectMap()
                     .append("files", files)
                     .append("study", studyStr);
-            OpenCGAResult<Job> result = catalogManager.getJobManager().submit(studyStr, "files-unlink", Enums.Priority.MEDIUM, params,
+            OpenCGAResult<Job> result = catalogManager.getJobManager().submit(studyStr, JobType.NATIVE, "files-unlink", Enums.Priority.MEDIUM, params,
                     token);
             return createOkResponse(result);
         } catch (Exception e) {
@@ -958,7 +959,7 @@ public Response delete(
                     .append("files", files)
                     .append("study", studyStr)
                     .append(Constants.SKIP_TRASH, skipTrash);
-            OpenCGAResult<Job> result = catalogManager.getJobManager().submit(studyStr, FileDeleteTask.ID, Enums.Priority.MEDIUM, params,
+            OpenCGAResult<Job> result = catalogManager.getJobManager().submit(studyStr, JobType.NATIVE, FileDeleteTask.ID, Enums.Priority.MEDIUM, params,
                     token);
             return createOkResponse(result);
         } catch (Exception e) {
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
index 2cce6b3ad8d..f8f819f13e6 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/JobWSServer.java
@@ -136,9 +136,9 @@ public Response runByPost(
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = NextFlowRunParams.DESCRIPTION, required = true) JobRunParams params) {
         ToolInfo toolInfo = new ToolInfo()
-                .setId("docker")
-                .setExternalExecutor(new ToolInfoExecutor(CustomToolExecutor.ID, ""));
-        return submitJob(toolInfo, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+                .setId(params.getDocker().getId());
+        return submitJob(study, JobType.CUSTOM, toolInfo, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime,
+                jobPriority, dryRun);
     }
 
     @POST
@@ -155,7 +155,7 @@ public Response dockerBuildByPost(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = "body", required = true) JobToolBuildParams params) {
-        return submitJob(CustomToolBuilder.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, CustomToolBuilder.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/OpenCGAWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/OpenCGAWSServer.java
index cdbe6329d78..911b97cb63b 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/OpenCGAWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/OpenCGAWSServer.java
@@ -47,6 +47,7 @@
 import org.opencb.opencga.core.models.JwtPayload;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.job.ToolInfo;
 import org.opencb.opencga.core.models.migration.MigrationRun;
 import org.opencb.opencga.core.models.study.Study;
@@ -853,43 +854,44 @@ public Response run(Callable<DataResult<?>> c) {
         }
     }
 
-    public Response submitJob(String toolId, String project, String study, Map<String, Object> paramsMap, String jobName,
+    public Response submitJob(String project, String study, JobType type, String toolId, Map<String, Object> paramsMap, String jobName,
                               String jobDescription, String jobDependsOne, String jobTags, String jobScheduledStartTime, String jobPriority,
                               Boolean dryRun) {
-        return run(() -> submitJobRaw(toolId, project, study, paramsMap, jobName, jobDescription, jobDependsOne, jobTags, jobScheduledStartTime, jobPriority, dryRun));
+        return run(() -> submitJobRaw(project, study, type, toolId, paramsMap, jobName, jobDescription, jobDependsOne, jobTags,
+                jobScheduledStartTime, jobPriority, dryRun));
     }
 
-    public Response submitJob(String toolId, String study, ToolParams bodyParams, String jobId, String jobDescription,
+    public Response submitJob(String study, JobType type, String toolId, ToolParams bodyParams, String jobId, String jobDescription,
                               String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority, Boolean dryRun) {
-        return submitJob(toolId, null, study, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun);
+        return submitJob(null, study, type, toolId, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime,
+                jobPriority, dryRun);
     }
 
-    public Response submitJobAdmin(String toolId, ToolParams bodyParams, String jobId, String jobDescription,
+    public Response submitJobAdmin(JobType type, String toolId, ToolParams bodyParams, String jobId, String jobDescription,
                                    String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority,
                                    Boolean dryRun) {
         return run(() -> {
             JwtPayload jwtPayload = catalogManager.getUserManager().validateToken(token);
             catalogManager.getAuthorizationManager().checkIsOpencgaAdministrator(jwtPayload, "submit job from tool '" + toolId + "'");
-            return submitJobRaw(toolId, null, ADMIN_STUDY_FQN, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun);
+            return submitJobRaw(null, ADMIN_STUDY_FQN, type, toolId, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr,
+                    jobScheduledStartTime, jobPriority, dryRun);
         });
     }
 
-    public Response submitJob(ToolInfo toolInfo, String study, ToolParams bodyParams, String jobId, String jobDescription,
-                              String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority, Boolean dryRun) {
-        return run(() -> submitJobRaw(toolInfo, null, study, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun));
-    }
-
-    public Response submitJob(ToolInfo toolInfo, String project, String study, ToolParams bodyParams, String jobId, String jobDescription,
+    public Response submitJob(String study, JobType type, ToolInfo toolInfo, ToolParams bodyParams, String jobId, String jobDescription,
                               String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority, Boolean dryRun) {
-        return run(() -> submitJobRaw(toolInfo, project, study, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun));
+        return run(() -> submitJobRaw(null, study, type, toolInfo, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr,
+                jobScheduledStartTime, jobPriority, dryRun));
     }
 
-    public Response submitJob(String toolId, String project, String study, ToolParams bodyParams, String jobId, String jobDescription,
-                              String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime, String jobPriority, Boolean dryRun) {
-        return run(() -> submitJobRaw(toolId, project, study, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun));
+    public Response submitJob(String project, String study, JobType type, String toolId, ToolParams bodyParams, String jobId,
+                              String jobDescription, String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime,
+                              String jobPriority, Boolean dryRun) {
+        return run(() -> submitJobRaw(project, study, type, toolId, bodyParams, jobId, jobDescription, jobDependsOnStr, jobTagsStr,
+                jobScheduledStartTime, jobPriority, dryRun));
     }
 
-    protected DataResult<Job> submitJobRaw(String toolId, String project, String study, ToolParams bodyParams, String jobId,
+    protected DataResult<Job> submitJobRaw(String project, String study, JobType type, String toolId, ToolParams bodyParams, String jobId,
                                            String jobDescription, String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime,
                                            String jobPriority, Boolean dryRun)
             throws CatalogException {
@@ -897,13 +899,13 @@ protected DataResult<Job> submitJobRaw(String toolId, String project, String stu
         if (StringUtils.isNotEmpty(study)) {
             paramsMap.putIfAbsent(ParamConstants.STUDY_PARAM, study);
         }
-        return submitJobRaw(toolId, project, study, paramsMap, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime, jobPriority, dryRun);
+        return submitJobRaw(project, study, type, toolId, paramsMap, jobId, jobDescription, jobDependsOnStr, jobTagsStr,
+                jobScheduledStartTime, jobPriority, dryRun);
     }
 
-    protected DataResult<Job> submitJobRaw(String toolId, String project, String study, Map<String, Object> paramsMap, String jobId,
-                                           String jobDescription, String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime,
-                                           String jobPriority, Boolean dryRun)
-            throws CatalogException {
+    protected DataResult<Job> submitJobRaw(String project, String study, JobType type, String toolId, Map<String, Object> paramsMap,
+                                           String jobId, String jobDescription, String jobDependsOnStr, String jobTagsStr,
+                                           String jobScheduledStartTime, String jobPriority, Boolean dryRun) throws CatalogException {
 
         if (StringUtils.isNotEmpty(project) && StringUtils.isEmpty(study)) {
             // Project job
@@ -938,26 +940,24 @@ protected DataResult<Job> submitJobRaw(String toolId, String project, String stu
             priority = Enums.Priority.getPriority(jobPriority.toUpperCase());
         }
         return catalogManager.getJobManager()
-                .submit(study, toolId, priority, paramsMap, jobId, jobDescription, jobDependsOn, jobTags, null,
-                        jobScheduledStartTime, dryRun, token);
+                .submit(study, type, toolId, priority, paramsMap, jobId, jobDescription, jobDependsOn, jobTags, null, jobScheduledStartTime,
+                        dryRun, token);
     }
 
-    protected DataResult<Job> submitJobRaw(ToolInfo toolInfo, String project, String study, ToolParams bodyParams, String jobId,
-                                           String jobDescription, String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime,
-                                           String jobPriority, Boolean dryRun)
-            throws CatalogException {
+    protected DataResult<Job> submitJobRaw(String project, String study, JobType type, ToolInfo toolInfo, ToolParams bodyParams,
+                                           String jobId, String jobDescription, String jobDependsOnStr, String jobTagsStr,
+                                           String jobScheduledStartTime, String jobPriority, Boolean dryRun) throws CatalogException {
         Map<String, Object> paramsMap = bodyParams.toParams();
         if (StringUtils.isNotEmpty(study)) {
             paramsMap.putIfAbsent(ParamConstants.STUDY_PARAM, study);
         }
-        return submitJobRaw(toolInfo, project, study, paramsMap, jobId, jobDescription, jobDependsOnStr, jobTagsStr, jobScheduledStartTime,
-                jobPriority, dryRun);
+        return submitJobRaw(study, project, type, toolInfo, paramsMap, jobId, jobDescription, jobDependsOnStr, jobTagsStr,
+                jobScheduledStartTime, jobPriority, dryRun);
     }
 
-    protected DataResult<Job> submitJobRaw(ToolInfo toolInfo, String project, String study, Map<String, Object> paramsMap, String jobId,
-                                           String jobDescription, String jobDependsOnStr, String jobTagsStr, String jobScheduledStartTime,
-                                           String jobPriority, Boolean dryRun)
-            throws CatalogException {
+    protected DataResult<Job> submitJobRaw(String study, String project, JobType type, ToolInfo toolInfo, Map<String, Object> paramsMap,
+                                           String jobId, String jobDescription, String jobDependsOnStr, String jobTagsStr,
+                                           String jobScheduledStartTime, String jobPriority, Boolean dryRun) throws CatalogException {
 
         if (StringUtils.isNotEmpty(project) && StringUtils.isEmpty(study)) {
             // Project job
@@ -992,7 +992,7 @@ protected DataResult<Job> submitJobRaw(ToolInfo toolInfo, String project, String
             priority = Enums.Priority.getPriority(jobPriority.toUpperCase());
         }
         return catalogManager.getJobManager()
-                .submit(study, toolInfo, priority, paramsMap, jobId, jobDescription, jobDependsOn, jobTags, null,
+                .submit(study, type, toolInfo, priority, paramsMap, jobId, jobDescription, jobDependsOn, jobTags, null,
                         jobScheduledStartTime, dryRun, Collections.emptyMap(), token);
     }
 
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/PanelWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/PanelWSServer.java
index 7d36dec4386..ce274bfb031 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/PanelWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/PanelWSServer.java
@@ -27,6 +27,7 @@
 import org.opencb.opencga.core.exceptions.VersionException;
 import org.opencb.opencga.core.models.AclParams;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.panel.*;
 import org.opencb.opencga.core.tools.annotations.*;
 
@@ -86,7 +87,7 @@ public Response importPanel(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(name = "body", value = "Panel parameters") PanelImportParams params) {
-        return submitJob(PanelImportTask.ID, studyStr, params, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(studyStr, JobType.NATIVE, PanelImportTask.ID, params, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
 //    @POST
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/StudyWSServer.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/StudyWSServer.java
index 8492d30c490..9c25b6680bd 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/StudyWSServer.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/StudyWSServer.java
@@ -35,6 +35,7 @@
 import org.opencb.opencga.core.models.audit.AuditRecord;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.notes.Note;
 import org.opencb.opencga.core.models.notes.NoteCreateParams;
 import org.opencb.opencga.core.models.notes.NoteUpdateParams;
@@ -554,7 +555,7 @@ public Response executeTemplate(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = TemplateParams.DESCRIPTION, required = true) TemplateParams params) {
-        return submitJob(TemplateRunner.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, TemplateRunner.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/AlignmentWebService.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/AlignmentWebService.java
index 277f289a6b6..4c98a5c8ec7 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/AlignmentWebService.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/AlignmentWebService.java
@@ -17,6 +17,7 @@
 package org.opencb.opencga.server.rest.analysis;
 
 import org.opencb.opencga.analysis.alignment.AlignmentCoverageAnalysis;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.tools.annotations.*;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -87,7 +88,7 @@ public Response indexRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = AlignmentIndexParams.DESCRIPTION, required = true) AlignmentIndexParams params) {
-        return submitJob(AlignmentIndexOperation.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, AlignmentIndexOperation.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     //-------------------------------------------------------------------------
@@ -185,7 +186,7 @@ public Response coverageRun(
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = CoverageIndexParams.DESCRIPTION, required = true) CoverageIndexParams params) {
 
-        return submitJob(AlignmentCoverageAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, AlignmentCoverageAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
 
         //        logger.debug("ObjectMap: {}", params);
 //
@@ -397,7 +398,7 @@ public Response geneCoverageStatsRun(
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = AlignmentGeneCoverageStatsParams.DESCRIPTION, required = true) AlignmentGeneCoverageStatsParams params) {
 
-        return submitJob(AlignmentGeneCoverageStatsAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, AlignmentGeneCoverageStatsAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     //-------------------------------------------------------------------------
@@ -418,7 +419,7 @@ public Response qcRun(
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = AlignmentQcParams.DESCRIPTION, required = true) AlignmentQcParams params) {
 
-        return submitJob(AlignmentQcAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, AlignmentQcAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     //-------------------------------------------------------------------------
@@ -438,7 +439,7 @@ public Response bwaRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = BwaWrapperParams.DESCRIPTION, required = true) BwaWrapperParams params) {
-        return submitJob(BwaWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, BwaWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -454,7 +455,7 @@ public Response samtoolsRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = SamtoolsWrapperParams.DESCRIPTION, required = true) SamtoolsWrapperParams params) {
-        return submitJob(SamtoolsWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, SamtoolsWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -470,7 +471,7 @@ public Response deeptoolsRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = DeeptoolsWrapperParams.DESCRIPTION, required = true) DeeptoolsWrapperParams params) {
-        return submitJob(DeeptoolsWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, DeeptoolsWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -486,7 +487,7 @@ public Response fastqcRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = FastqcWrapperParams.DESCRIPTION, required = true) FastqcWrapperParams params) {
-        return submitJob(FastqcWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, FastqcWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -502,7 +503,7 @@ public Response picardRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = PicardWrapperParams.DESCRIPTION, required = true) PicardWrapperParams params) {
-        return submitJob(PicardWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, PicardWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     //-------------------------------------------------------------------------
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/ClinicalWebService.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/ClinicalWebService.java
index 3dd6fa53aa4..d4b1aecbb2d 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/ClinicalWebService.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/ClinicalWebService.java
@@ -47,6 +47,7 @@
 import org.opencb.opencga.core.models.clinical.*;
 import org.opencb.opencga.core.models.common.TsvAnnotationParams;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.sample.Sample;
 import org.opencb.opencga.core.models.study.configuration.ClinicalAnalysisStudyConfiguration;
 import org.opencb.opencga.core.tools.annotations.*;
@@ -176,7 +177,7 @@ public Response load(
             @ApiParam(value = ClinicalAnalysisLoadParams.DESCRIPTION, required = true) ClinicalAnalysisLoadParams params) {
         try {
             // Execute load as a job
-            return submitJob(ClinicalAnalysisLoadTask.ID, study, params, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+            return submitJob(study, JobType.NATIVE, ClinicalAnalysisLoadTask.ID, params, jobId, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
         } catch (Exception e) {
             return createErrorResponse("Load clinical analyses from file", e.getMessage());
         }
@@ -1180,9 +1181,9 @@ public Response rgaIndexRun(
             if (StringUtils.isNotEmpty(study)) {
                 paramsMap.putIfAbsent(ParamConstants.STUDY_PARAM, study);
             }
-            return submitJob(AuxiliarRgaAnalysis.ID, null, study, paramsMap, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+            return submitJob(null, study, JobType.NATIVE, AuxiliarRgaAnalysis.ID, paramsMap, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
         } else {
-            return submitJob(RgaAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+            return submitJob(study, JobType.NATIVE, RgaAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
         }
     }
 
@@ -1307,7 +1308,7 @@ public Response interpretationTieringRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = TieringInterpretationAnalysisParams.DESCRIPTION, required = true) TieringInterpretationAnalysisParams params) {
-        return submitJob(TieringInterpretationAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, TieringInterpretationAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
 
@@ -1324,7 +1325,7 @@ public Response interpretationExomiserRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = ExomiserInterpretationAnalysisParams.DESCRIPTION, required = true) ExomiserInterpretationAnalysisParams params) {
-        return submitJob(ExomiserInterpretationAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, ExomiserInterpretationAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1340,7 +1341,7 @@ public Response interpretationTeamRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = TeamInterpretationAnalysisParams.DESCRIPTION, required = true) TeamInterpretationAnalysisParams params) {
-        return submitJob(TeamInterpretationAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, TeamInterpretationAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1356,7 +1357,7 @@ public Response interpretationZettaRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = ZettaInterpretationAnalysisParams.DESCRIPTION, required = true) ZettaInterpretationAnalysisParams params) {
-        return submitJob(ZettaInterpretationAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, ZettaInterpretationAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1372,6 +1373,6 @@ public Response interpretationCancerTieringRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = CancerTieringInterpretationAnalysisParams.DESCRIPTION, required = true) CancerTieringInterpretationAnalysisParams params) {
-        return submitJob(CancerTieringInterpretationAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, CancerTieringInterpretationAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 }
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/VariantWebService.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/VariantWebService.java
index 27b756538f6..8e1c4289659 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/VariantWebService.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/analysis/VariantWebService.java
@@ -71,6 +71,7 @@
 import org.opencb.opencga.core.models.cohort.Cohort;
 import org.opencb.opencga.core.models.common.AnnotationSet;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.operations.variant.VariantFileDeleteParams;
 import org.opencb.opencga.core.models.operations.variant.VariantIndexParams;
 import org.opencb.opencga.core.models.operations.variant.VariantStatsExportParams;
@@ -191,7 +192,7 @@ public Response variantFileIndex(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = VariantIndexParams.DESCRIPTION, required = true) VariantIndexParams params) {
-        return submitJob(VariantIndexOperationTool.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, VariantIndexOperationTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @Deprecated
@@ -210,7 +211,7 @@ public Response variantFileDelete(
             @ApiParam(value = "Files to remove") @QueryParam("file") String file,
             @ApiParam(value = "Resume a previously failed indexation") @QueryParam("resume") boolean resume) throws WebServiceException {
         VariantFileDeleteParams params = new VariantFileDeleteParams(getIdList(file), resume);
-        return submitJob(VariantFileDeleteOperationTool.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, VariantFileDeleteOperationTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
@@ -409,7 +410,7 @@ public Response export(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = VariantExportParams.DESCRIPTION, required = true) VariantExportParams params) {
-        return submitJob(VariantExportTool.ID, project, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(project, study, JobType.NATIVE, VariantExportTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
@@ -455,7 +456,7 @@ public Response statsRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = VariantStatsAnalysisParams.DESCRIPTION, required = true) VariantStatsAnalysisParams params) {
-        return submitJob(VariantStatsAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, VariantStatsAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -472,7 +473,7 @@ public Response statsExport(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = VariantStatsExportParams.DESCRIPTION, required = true) VariantStatsExportParams params) {
-        return submitJob("variant-stats-export", project, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(project, study, JobType.NATIVE, "variant-stats-export", params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
 //    public static class StatsDeleteParams extends ToolParams {
@@ -578,7 +579,7 @@ public Response sampleRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = SampleVariantFilterParams.DESCRIPTION, required = true) SampleVariantFilterParams params) {
-        return submitJob(SampleVariantFilterAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, SampleVariantFilterAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -594,7 +595,7 @@ public Response sampleEligibility(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = SampleEligibilityAnalysisParams.DESCRIPTION, required = true) SampleEligibilityAnalysisParams params) {
-        return submitJob(SampleEligibilityAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, SampleEligibilityAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -610,7 +611,7 @@ public Response exomiserRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = ExomiserWrapperParams.DESCRIPTION, required = true) ExomiserWrapperParams params) {
-        return submitJob(ExomiserWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, ExomiserWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
 
@@ -708,7 +709,7 @@ public Response sampleStatsRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = SampleVariantStatsAnalysisParams.DESCRIPTION, required = true) SampleVariantStatsAnalysisParams params) {
-        return submitJob(SampleVariantStatsAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, SampleVariantStatsAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
@@ -760,7 +761,7 @@ public Response cohortStatsRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = CohortVariantStatsAnalysisParams.DESCRIPTION, required = true) CohortVariantStatsAnalysisParams params) {
-        return submitJob(CohortVariantStatsAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, CohortVariantStatsAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
@@ -936,7 +937,7 @@ public Response gwasRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = GwasAnalysisParams.DESCRIPTION, required = true) GwasAnalysisParams params) {
-        return submitJob(GwasAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, GwasAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
 //    @POST
@@ -966,7 +967,7 @@ public Response mutationalSignatureRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = MutationalSignatureAnalysisParams.DESCRIPTION, required = true) MutationalSignatureAnalysisParams params) {
-        return submitJob(MutationalSignatureAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, MutationalSignatureAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
@@ -1084,7 +1085,7 @@ public Response hrDetectRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = HRDetectAnalysisParams.DESCRIPTION, required = true) HRDetectAnalysisParams params) {
-        return submitJob(HRDetectAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, HRDetectAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1100,7 +1101,7 @@ public Response mendelianErrorRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = MendelianErrorAnalysisParams.DESCRIPTION, required = true) MendelianErrorAnalysisParams params) {
-        return submitJob(MendelianErrorAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, MendelianErrorAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1121,7 +1122,7 @@ public Response inferredSexRun(
             InferredSexAnalysis.checkParameters(params.getIndividual(), params.getSample(), study, catalogManager, token);
 
             // Submit the inferred sex analysis
-            return submitJobRaw(InferredSexAnalysis.ID, null, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+            return submitJobRaw(null, study, JobType.NATIVE, InferredSexAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
         });
     }
 
@@ -1138,7 +1139,7 @@ public Response relatednessRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = RelatednessAnalysisParams.DESCRIPTION, required = true) RelatednessAnalysisParams params) {
-        return submitJob(RelatednessAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, RelatednessAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1154,7 +1155,7 @@ public Response familyQcRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = FamilyQcAnalysisParams.DESCRIPTION, required = true) FamilyQcAnalysisParams params) {
-        return submitJob(FamilyQcAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, FamilyQcAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1176,7 +1177,7 @@ public Response individualQcRun(
                     catalogManager, token);
 
             // Submit the individual QC analysis
-            return submitJobRaw(IndividualQcAnalysis.ID, null, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+            return submitJobRaw(null, study, JobType.NATIVE, IndividualQcAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
         });
     }
 
@@ -1194,7 +1195,7 @@ public Response sampleQcRun(
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = SampleQcAnalysisParams.DESCRIPTION, required = true) SampleQcAnalysisParams params) {
 
-        return submitJob(SampleQcAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, SampleQcAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1210,7 +1211,7 @@ public Response liftoverRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = LiftoverWrapperParams.DESCRIPTION, required = true) LiftoverWrapperParams params) {
-        return submitJob(LiftoverWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, LiftoverWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1226,7 +1227,7 @@ public Response plinkRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = PlinkWrapperParams.DESCRIPTION, required = true) PlinkWrapperParams params) {
-        return submitJob(PlinkWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, PlinkWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1242,7 +1243,7 @@ public Response rvtestsRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = RvtestsWrapperParams.DESCRIPTION, required = true) RvtestsWrapperParams params) {
-        return submitJob(RvtestsWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, RvtestsWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1258,7 +1259,7 @@ public Response gatkRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = GatkWrapperParams.DESCRIPTION, required = true) GatkWrapperParams params) {
-        return submitJob(GatkWrapperAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, GatkWrapperAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -1274,7 +1275,7 @@ public Response knockoutRun(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = KnockoutAnalysisParams.DESCRIPTION, required = true) KnockoutAnalysisParams params) {
-        return submitJob(KnockoutAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, KnockoutAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @GET
@@ -1320,7 +1321,7 @@ public Response genomePlotRun(
             @ApiParam(value = GenomePlotAnalysisParams.DESCRIPTION, required = true) GenomePlotAnalysisParams params) {
         // To be sure: do not update quality control sample
         params.setSample(null);
-        return submitJob(GenomePlotAnalysis.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, GenomePlotAnalysis.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
diff --git a/opencga-server/src/main/java/org/opencb/opencga/server/rest/operations/VariantOperationWebService.java b/opencga-server/src/main/java/org/opencb/opencga/server/rest/operations/VariantOperationWebService.java
index 14fb051c85c..9efd263ba00 100644
--- a/opencga-server/src/main/java/org/opencb/opencga/server/rest/operations/VariantOperationWebService.java
+++ b/opencga-server/src/main/java/org/opencb/opencga/server/rest/operations/VariantOperationWebService.java
@@ -28,6 +28,7 @@
 import org.opencb.opencga.core.config.storage.SampleIndexConfiguration;
 import org.opencb.opencga.core.exceptions.VersionException;
 import org.opencb.opencga.core.models.job.Job;
+import org.opencb.opencga.core.models.job.JobType;
 import org.opencb.opencga.core.models.operations.variant.*;
 import org.opencb.opencga.core.models.study.VariantSetupResult;
 import org.opencb.opencga.core.models.variant.*;
@@ -196,7 +197,7 @@ public Response variantMetadataSynchronize(
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = ParamConstants.STUDY_DESCRIPTION) @QueryParam(ParamConstants.STUDY_PARAM) String study,
             @ApiParam(value = VariantStorageMetadataSynchronizeParams.DESCRIPTION) VariantStorageMetadataSynchronizeParams params) {
-        return submitJobAdmin(VariantStorageMetadataSynchronizeOperationTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJobAdmin(JobType.NATIVE, VariantStorageMetadataSynchronizeOperationTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -211,7 +212,7 @@ public Response variantMetadataRepair(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = VariantStorageMetadataRepairToolParams.DESCRIPTION) VariantStorageMetadataRepairToolParams params) {
-        return submitJobAdmin(VariantStorageMetadataRepairTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJobAdmin(JobType.NATIVE, VariantStorageMetadataRepairTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -227,7 +228,7 @@ public Response statsIndex(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = VariantStatsAnalysisParams.DESCRIPTION, required = true) VariantStatsIndexParams params) {
-        return submitJob(VariantStatsIndexOperationTool.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, VariantStatsIndexOperationTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
     @POST
@@ -243,7 +244,7 @@ public Response statsDelete(
             @ApiParam(value = ParamConstants.JOB_PRIORITY_DESCRIPTION) @QueryParam(ParamConstants.SUBMIT_JOB_PRIORITY_PARAM) String jobPriority,
             @ApiParam(value = ParamConstants.JOB_DRY_RUN_DESCRIPTION) @QueryParam(ParamConstants.JOB_DRY_RUN) Boolean dryRun,
             @ApiParam(value = VariantStatsDeleteParams.DESCRIPTION, required = true) VariantStatsDeleteParams params) {
-        return submitJob(VariantStatsDeleteOperationTool.ID, study, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
+        return submitJob(study, JobType.NATIVE, VariantStatsDeleteOperationTool.ID, params, jobName, jobDescription, dependsOn, jobTags, scheduledStartTime, jobPriority, dryRun);
     }
 
 
@@ -635,6 +636,6 @@ public Response submitOperation(String toolId, String project, String study, Map
         if (dynamicParamsMap.size() > 0) {
             paramsMap.put("dynamicParams", dynamicParamsMap);
         }
-        return submitJob(toolId, project, study, paramsMap, jobName, jobDescription, jobDependsOne, jobTags, jobScheduledStartTime, jobPriority, dryRun);
+        return submitJob(project, study, JobType.NATIVE, toolId, paramsMap, jobName, jobDescription, jobDependsOne, jobTags, jobScheduledStartTime, jobPriority, dryRun);
     }
 }

From 3e2964e2194c774f6e03ca8b405060a21be4d0dc Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Fri, 8 Nov 2024 13:03:25 +0100
Subject: [PATCH 93/99] analysis: add cellbase dependency, #TASK-6445

---
 .../opencga/analysis/tools/OpenCgaTool.java   | 56 +++++++++++++++++++
 .../analysis/workflow/NextFlowExecutor.java   | 14 ++++-
 .../catalog/managers/ProjectManager.java      |  2 +
 .../opencga/core/tools/ToolDependency.java    |  5 ++
 .../core/tools/result/ExecutionResult.java    | 11 ++++
 .../tools/result/ExecutionResultManager.java  | 12 ++++
 6 files changed, 99 insertions(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
index fe89b3f211a..f2d5b213a82 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
@@ -26,8 +26,12 @@
 import org.opencb.opencga.analysis.variant.manager.VariantStorageManager;
 import org.opencb.opencga.catalog.exceptions.CatalogException;
 import org.opencb.opencga.catalog.managers.CatalogManager;
+import org.opencb.opencga.catalog.managers.ProjectManager;
+import org.opencb.opencga.catalog.managers.StudyManager;
+import org.opencb.opencga.catalog.utils.CatalogFqn;
 import org.opencb.opencga.core.api.ParamConstants;
 import org.opencb.opencga.core.common.ExceptionUtils;
+import org.opencb.opencga.core.common.GitRepositoryState;
 import org.opencb.opencga.core.common.MemoryUsageMonitor;
 import org.opencb.opencga.core.common.TimeUtils;
 import org.opencb.opencga.core.config.Configuration;
@@ -36,7 +40,10 @@
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.file.File;
 import org.opencb.opencga.core.models.project.DataStore;
+import org.opencb.opencga.core.models.project.Project;
+import org.opencb.opencga.core.models.study.Study;
 import org.opencb.opencga.core.tools.OpenCgaToolExecutor;
+import org.opencb.opencga.core.tools.ToolDependency;
 import org.opencb.opencga.core.tools.ToolParams;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolExecutor;
@@ -55,6 +62,7 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.LinkedList;
 import java.util.List;
 
 import static org.opencb.opencga.core.tools.OpenCgaToolExecutor.EXECUTOR_ID;
@@ -253,6 +261,7 @@ public final ExecutionResult start() throws ToolException {
                 } else {
                     currentStep = null;
                     erm.setSteps(getSteps());
+                    erm.addDependencies(getDependencies());
                     run();
                 }
             } catch (ToolException e) {
@@ -380,6 +389,45 @@ protected List<String> getSteps() {
         return steps;
     }
 
+    protected List<ToolDependency> getDependencies() throws ToolException {
+        List<ToolDependency> dependencyList = new LinkedList<>();
+        dependencyList.add(new ToolDependency("opencga", GitRepositoryState.getInstance().getBuildVersion(),
+                GitRepositoryState.getInstance().getCommitId()));
+        ToolDependency cellbaseDependency = getCellbaseDependency();
+        if (cellbaseDependency != null) {
+            dependencyList.add(cellbaseDependency);
+        }
+        return dependencyList;
+    }
+
+    private ToolDependency getCellbaseDependency() throws ToolException {
+        String studyId = null;
+        String projectId = null;
+        if (StringUtils.isNotEmpty(params.getString(ParamConstants.PROJECT_PARAM))) {
+            projectId = params.getString(ParamConstants.PROJECT_PARAM);
+        } else if (StringUtils.isNotEmpty(params.getString(ParamConstants.STUDY_PARAM))) {
+            studyId = params.getString(ParamConstants.STUDY_PARAM);
+        } else {
+            return null;
+        }
+        try {
+            if (StringUtils.isNotEmpty(studyId)) {
+                Study study = catalogManager.getStudyManager().get(studyId, StudyManager.INCLUDE_STUDY_IDS, token).first();
+                CatalogFqn catalogFqn = CatalogFqn.extractFqnFromStudyFqn(study.getFqn());
+                projectId = catalogFqn.toProjectFqn();
+            }
+            Project project = catalogManager.getProjectManager().get(projectId, ProjectManager.INCLUDE_CELLBASE, token)
+                    .first();
+            if (project.getCellbase() != null) {
+                return new ToolDependency("cellbase:" + project.getCellbase().getDataRelease(), project.getCellbase().getVersion());
+            } else {
+                return null;
+            }
+        } catch (CatalogException e) {
+            throw new ToolException(e);
+        }
+    }
+
     protected final String getCurrentStep() {
         if (currentStep == null) {
             return getSteps().get(0);
@@ -522,6 +570,14 @@ protected final void addAttribute(String key, Object value) throws ToolException
         erm.addAttribute(key, value);
     }
 
+    protected final void addDependencies(List<ToolDependency> dependencyList) throws ToolException {
+        erm.addDependencies(dependencyList);
+    }
+
+    protected final void addDependency(ToolDependency dependency) throws ToolException {
+        erm.addDependency(dependency);
+    }
+
     protected final void moveFile(String study, Path source, Path destiny, String catalogDirectoryPath, String token) throws ToolException {
         File file;
         try {
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 1766faef746..0c07fa314a5 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -18,8 +18,12 @@
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.models.common.Enums;
 import org.opencb.opencga.core.models.job.ToolInfoExecutor;
-import org.opencb.opencga.core.models.workflow.*;
+import org.opencb.opencga.core.models.workflow.NextFlowRunParams;
+import org.opencb.opencga.core.models.workflow.Workflow;
+import org.opencb.opencga.core.models.workflow.WorkflowScript;
+import org.opencb.opencga.core.models.workflow.WorkflowVariable;
 import org.opencb.opencga.core.response.OpenCGAResult;
+import org.opencb.opencga.core.tools.ToolDependency;
 import org.opencb.opencga.core.tools.annotations.Tool;
 import org.opencb.opencga.core.tools.annotations.ToolParams;
 import org.opencb.opencga.core.tools.result.Status;
@@ -111,6 +115,14 @@ protected void check() throws Exception {
         if (CollectionUtils.isNotEmpty(workflow.getTags())) {
             tags.addAll(workflow.getTags());
         }
+        List<ToolDependency> dependencyList = new ArrayList<>(4);
+        dependencyList.add(new ToolDependency("opencb/opencga-workflow", "TASK-6445"));
+        dependencyList.add(new ToolDependency("nextflow", workflow.getManager().getVersion()));
+        dependencyList.add(new ToolDependency(workflow.getId(), String.valueOf(workflow.getVersion())));
+        if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getId())) {
+            dependencyList.add(new ToolDependency(workflow.getRepository().getId(), workflow.getRepository().getVersion()));
+        }
+        addDependencies(dependencyList);
         updateJobInformation(new ArrayList<>(tags), toolInfoExecutor);
 
         StringBuilder cliParamsBuilder = new StringBuilder();
diff --git a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/ProjectManager.java b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/ProjectManager.java
index 92591852817..eb92437b06f 100644
--- a/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/ProjectManager.java
+++ b/opencga-catalog/src/main/java/org/opencb/opencga/catalog/managers/ProjectManager.java
@@ -78,6 +78,8 @@ public class ProjectManager extends AbstractManager {
     public static final QueryOptions INCLUDE_PROJECT_IDS = new QueryOptions(QueryOptions.INCLUDE, Arrays.asList(
             ProjectDBAdaptor.QueryParams.UID.key(), ProjectDBAdaptor.QueryParams.ID.key(), ProjectDBAdaptor.QueryParams.UUID.key(),
             ProjectDBAdaptor.QueryParams.FQN.key()));
+    public static final QueryOptions INCLUDE_CELLBASE = keepFieldInQueryOptions(INCLUDE_PROJECT_IDS,
+            ProjectDBAdaptor.QueryParams.CELLBASE.key());
 
     ProjectManager(AuthorizationManager authorizationManager, AuditManager auditManager, CatalogManager catalogManager,
                    DBAdaptorFactory catalogDBAdaptorFactory, CatalogIOManager catalogIOManager, Configuration configuration) {
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/tools/ToolDependency.java b/opencga-core/src/main/java/org/opencb/opencga/core/tools/ToolDependency.java
index df5f07d653a..4f3425244aa 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/tools/ToolDependency.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/tools/ToolDependency.java
@@ -9,6 +9,11 @@ public class ToolDependency {
     public ToolDependency() {
     }
 
+    public ToolDependency(String id, String version) {
+        this.id = id;
+        this.version = version;
+    }
+
     public ToolDependency(String id, String version, String commit) {
         this.id = id;
         this.version = version;
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResult.java b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResult.java
index 412d1695f88..9426a205504 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResult.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResult.java
@@ -72,6 +72,7 @@ public class ExecutionResult {
     public ExecutionResult() {
         executor = new ExecutorInfo();
         status = Status.initStatus();
+        dependencies = new LinkedList<>();
         events = new LinkedList<>();
         externalFiles = new LinkedList<>();
         steps = new LinkedList<>();
@@ -85,6 +86,7 @@ public String toString() {
         sb.append(", start=").append(start);
         sb.append(", end=").append(end);
         sb.append(", status=").append(status);
+        sb.append(", dependencies=").append(dependencies);
         sb.append(", externalFiles=").append(externalFiles);
         sb.append(", steps=").append(steps);
         sb.append(", events=").append(events);
@@ -147,6 +149,15 @@ public ExecutionResult setEvents(List<Event> events) {
         return this;
     }
 
+    public List<ToolDependency> getDependencies() {
+        return dependencies;
+    }
+
+    public ExecutionResult setDependencies(List<ToolDependency> dependencies) {
+        this.dependencies = dependencies;
+        return this;
+    }
+
     public List<URI> getExternalFiles() {
         return externalFiles;
     }
diff --git a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
index ac3171e4542..7e7bd57e643 100644
--- a/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
+++ b/opencga-core/src/main/java/org/opencb/opencga/core/tools/result/ExecutionResultManager.java
@@ -29,6 +29,7 @@
 import org.opencb.opencga.core.common.JacksonUtils;
 import org.opencb.opencga.core.exceptions.ToolException;
 import org.opencb.opencga.core.tools.OpenCgaToolExecutor;
+import org.opencb.opencga.core.tools.ToolDependency;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -261,6 +262,17 @@ public void addStepAttribute(String key, Object value) throws ToolException {
         });
     }
 
+    public void addDependency(ToolDependency dependency) throws ToolException {
+        addDependencies(Collections.singletonList(dependency));
+    }
+
+    public void addDependencies(List<ToolDependency> dependencyList) throws ToolException {
+        updateResult(result -> {
+            result.getDependencies().addAll(dependencyList);
+            return null;
+        });
+    }
+
     public void setManualSteps(List<ToolStep> steps) throws ToolException {
         updateResult(result -> result.setSteps(steps));
     }

From fc9d19b9acdb2eb0ce603a5a072e376e820c0b0a Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 12 Nov 2024 13:00:46 +0100
Subject: [PATCH 94/99] analysis: add opencga-token to external executions,
 #TASK-6445

---
 .../analysis/customTool/CustomToolExecutor.java        |  3 ++-
 .../org/opencb/opencga/analysis/tools/OpenCgaTool.java |  4 ++++
 .../opencga/analysis/workflow/NextFlowExecutor.java    | 10 ++++++++--
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
index 041b195d842..eaf136eb3bc 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
@@ -60,7 +60,8 @@ protected void check() throws Exception {
         tags.add(this.dockerImage);
         updateJobInformation(tags, toolInfoExecutor);
 
-        StringBuilder cliParamsBuilder = new StringBuilder();
+        StringBuilder cliParamsBuilder = new StringBuilder()
+                .append(" --opencga-token ").append(refreshToken());
         processInputParams(runParams.getCommandLine(), cliParamsBuilder);
         this.cliParams = cliParamsBuilder.toString();
     }
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
index f2d5b213a82..9f66fc4b183 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
@@ -474,6 +474,10 @@ public final ObjectMap getParams() {
         return params;
     }
 
+    public final String refreshToken() throws CatalogException {
+        return catalogManager.getUserManager().refreshToken(token).getToken();
+    }
+
     private ToolParams findToolParams() throws ToolException {
         for (Field field : getClass().getDeclaredFields()) {
             if (field.isAnnotationPresent(org.opencb.opencga.core.tools.annotations.ToolParams.class)
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 0c07fa314a5..02669867272 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -208,7 +208,11 @@ protected void run() throws Exception {
 
         String dockerImage = "opencb/opencga-workflow:TASK-6445";
         StringBuilder stringBuilder = new StringBuilder()
-                .append("bash -c \"NXF_VER=").append(workflow.getManager().getVersion()).append(" nextflow -c ").append(nextflowConfigPath).append(" run ");
+                .append("bash -c \"NXF_VER=")
+                .append(workflow.getManager().getVersion())
+                .append(" nextflow -c ")
+                .append(nextflowConfigPath)
+                .append(" run ");
         if (workflow.getRepository() != null && StringUtils.isNotEmpty(workflow.getRepository().getId())) {
 //            stringBuilder.append(workflow.getRepository().getImage()).append(" -with-docker");
             stringBuilder.append(workflow.getRepository().getId());
@@ -223,7 +227,9 @@ protected void run() throws Exception {
         if (StringUtils.isNotEmpty(cliParams)) {
             stringBuilder.append(" ").append(cliParams);
         }
-        stringBuilder.append(" -with-report ").append(outDirPath).append("/report.html\"");
+        stringBuilder
+                .append(" --opencga-token ").append(refreshToken())
+                .append(" -with-report ").append(outDirPath).append("/report.html\"");
 
         startTraceFileMonitor();
 

From 6a17eec896679ae70f1718369613c7b7f59d87dc Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Tue, 12 Nov 2024 14:55:04 +0100
Subject: [PATCH 95/99] analysis: send token as an environment variable,
 #TASK-6445

---
 .../analysis/customTool/CustomToolExecutor.java       | 11 ++++++++---
 .../opencb/opencga/analysis/tools/OpenCgaTool.java    |  2 +-
 .../opencga/analysis/workflow/NextFlowExecutor.java   |  5 ++---
 3 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
index eaf136eb3bc..e9ccd1a347f 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/customTool/CustomToolExecutor.java
@@ -14,8 +14,10 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 
 @Tool(id = CustomToolExecutor.ID, resource = Enums.Resource.JOB, description = CustomToolExecutor.DESCRIPTION)
 public class CustomToolExecutor extends OpenCgaDockerToolScopeStudy {
@@ -60,8 +62,7 @@ protected void check() throws Exception {
         tags.add(this.dockerImage);
         updateJobInformation(tags, toolInfoExecutor);
 
-        StringBuilder cliParamsBuilder = new StringBuilder()
-                .append(" --opencga-token ").append(refreshToken());
+        StringBuilder cliParamsBuilder = new StringBuilder();
         processInputParams(runParams.getCommandLine(), cliParamsBuilder);
         this.cliParams = cliParamsBuilder.toString();
     }
@@ -69,7 +70,11 @@ protected void check() throws Exception {
     @Override
     protected void run() throws Exception {
         StopWatch stopWatch = StopWatch.createStarted();
-        String cmdline = runDocker(dockerImage, cliParams);
+
+        Map<String, String> dockerParams = new HashMap<>();
+        dockerParams.put("-e", "OPENCGA_TOKEN=" + getExpiringToken());
+        String cmdline = runDocker(dockerImage, null, cliParams, dockerParams);
+
         logger.info("Docker command line: " + cmdline);
         logger.info("Execution time: " + TimeUtils.durationToString(stopWatch));
     }
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
index 9f66fc4b183..e9d8b1b4d6b 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/OpenCgaTool.java
@@ -474,7 +474,7 @@ public final ObjectMap getParams() {
         return params;
     }
 
-    public final String refreshToken() throws CatalogException {
+    public final String getExpiringToken() throws CatalogException {
         return catalogManager.getUserManager().refreshToken(token).getToken();
     }
 
diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
index 02669867272..6a516c76ba2 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/workflow/NextFlowExecutor.java
@@ -227,9 +227,7 @@ protected void run() throws Exception {
         if (StringUtils.isNotEmpty(cliParams)) {
             stringBuilder.append(" ").append(cliParams);
         }
-        stringBuilder
-                .append(" --opencga-token ").append(refreshToken())
-                .append(" -with-report ").append(outDirPath).append("/report.html\"");
+        stringBuilder.append(" -with-report ").append(outDirPath).append("/report.html\"");
 
         startTraceFileMonitor();
 
@@ -237,6 +235,7 @@ protected void run() throws Exception {
         // Set HOME environment variable to the temporal input directory. This is because nextflow creates a hidden folder there and,
         // when nextflow runs on other dockers, we need to store those files in a path shared between the parent docker and the host
         dockerParams.put("-e", "HOME=" + temporalInputDir);
+        dockerParams.put("-e", "OPENCGA_TOKEN=" + getExpiringToken());
 
         // Execute docker image
         StopWatch stopWatch = StopWatch.createStarted();

From d0d8346c7349276d5313464fd6b8c215c1015f43 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 13 Nov 2024 11:58:05 +0100
Subject: [PATCH 96/99] app: create migration scripts, #TASK-6445

---
 .../v4/v4_0_0/catalog/IndexesTask6445.java    | 16 +++++++++
 .../JobModelChangesMigrationTask6445.java     | 34 +++++++++++++++++++
 .../src/main/resources/catalog-indexes.txt    |  1 -
 3 files changed, 50 insertions(+), 1 deletion(-)
 create mode 100644 opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/IndexesTask6445.java
 create mode 100644 opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/JobModelChangesMigrationTask6445.java

diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/IndexesTask6445.java b/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/IndexesTask6445.java
new file mode 100644
index 00000000000..06862c5b8c8
--- /dev/null
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/IndexesTask6445.java
@@ -0,0 +1,16 @@
+package org.opencb.opencga.app.migrations.v4.v4_0_0.catalog;
+
+import org.opencb.opencga.catalog.migration.Migration;
+import org.opencb.opencga.catalog.migration.MigrationTool;
+
+@Migration(id = "new_indexes_6445",
+        description = "New indexes from #TASK-6445", version = "4.0.0",
+        language = Migration.MigrationLanguage.JAVA, domain = Migration.MigrationDomain.CATALOG, date = 20241113)
+public class IndexesTask6445 extends MigrationTool {
+
+    @Override
+    protected void run() throws Exception {
+        catalogManager.installIndexes(organizationId, token);
+    }
+
+}
diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/JobModelChangesMigrationTask6445.java b/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/JobModelChangesMigrationTask6445.java
new file mode 100644
index 00000000000..74441fdc005
--- /dev/null
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/JobModelChangesMigrationTask6445.java
@@ -0,0 +1,34 @@
+package org.opencb.opencga.app.migrations.v4.v4_0_0.catalog;
+
+
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.model.Updates;
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.opencb.opencga.catalog.db.mongodb.OrganizationMongoDBAdaptorFactory;
+import org.opencb.opencga.catalog.migration.Migration;
+import org.opencb.opencga.catalog.migration.MigrationTool;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+@Migration(id = "job_model_changes_6445",
+        description = "Job data model changes #TASK-6445", version = "4.0.0",
+        language = Migration.MigrationLanguage.JAVA, domain = Migration.MigrationDomain.CATALOG, date = 20241113)
+public class JobModelChangesMigrationTask6445 extends MigrationTool {
+
+    @Override
+    protected void run() throws Exception {
+        Bson query = Filters.exists("type", false);
+        Bson update = Updates.combine(
+                Updates.set("type", "NATIVE"),
+                Updates.set("tool.minimumRequirements", new Document()),
+                Updates.set("execution.dependencies", Collections.emptyList())
+        );
+        for (String collection : Arrays.asList(OrganizationMongoDBAdaptorFactory.JOB_COLLECTION,
+                OrganizationMongoDBAdaptorFactory.DELETED_JOB_COLLECTION)) {
+            getMongoCollection(collection).updateMany(query, update);
+        }
+    }
+
+}
diff --git a/opencga-catalog/src/main/resources/catalog-indexes.txt b/opencga-catalog/src/main/resources/catalog-indexes.txt
index 2d0dc01ad92..7323423ce6c 100644
--- a/opencga-catalog/src/main/resources/catalog-indexes.txt
+++ b/opencga-catalog/src/main/resources/catalog-indexes.txt
@@ -20,7 +20,6 @@
 {"collections": ["job"], "fields": {"id": 1, "studyUid": 1}, "options": {"unique": true}}
 {"collections": ["job"], "fields": {"tool.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"tool.type": 1, "studyUid": 1}, "options": {}}
-{"collections": ["job"], "fields": {"tool.externalExecutor.id": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"userId": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"parentId": 1, "studyUid": 1}, "options": {}}
 {"collections": ["job"], "fields": {"outDir.uid": 1, "studyUid": 1}, "options": {}}

From 18bb5fe33182ef96070d84160a08886850d3a1de Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 13 Nov 2024 12:17:20 +0100
Subject: [PATCH 97/99] analysis: fix ToolRunner to get proper toolId,
 #TASK-6445

---
 .../java/org/opencb/opencga/analysis/tools/ToolRunner.java     | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolRunner.java b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolRunner.java
index 4a1dd9cf02d..14431730c89 100644
--- a/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolRunner.java
+++ b/opencga-analysis/src/main/java/org/opencb/opencga/analysis/tools/ToolRunner.java
@@ -105,7 +105,8 @@ public ExecutionResult execute(Job job, String token) throws CatalogException, T
      * @throws ToolException if the execution fails
      */
     public ExecutionResult execute(Job job, Path outDir, String token) throws CatalogException, ToolException {
-        return execute(job.getTool().getId(), new ObjectMap(job.getParams()), outDir, job.getId(), job.isDryRun(), token);
+        String toolId = ToolFactory.getToolId(job.getType(), job.getTool());
+        return execute(toolId, new ObjectMap(job.getParams()), outDir, job.getId(), job.isDryRun(), token);
     }
 
     /**

From 93c141b15df0014098781ccbdc6554cc2c210a53 Mon Sep 17 00:00:00 2001
From: pfurio <pedrofurio@gmail.com>
Date: Wed, 13 Nov 2024 14:51:34 +0100
Subject: [PATCH 98/99] app: fix possible migration issues, #TASK-6445

---
 .../JobModelChangesMigrationTask6445.java     | 22 ++++++++++++++-----
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/JobModelChangesMigrationTask6445.java b/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/JobModelChangesMigrationTask6445.java
index 74441fdc005..aa1ade35e87 100644
--- a/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/JobModelChangesMigrationTask6445.java
+++ b/opencga-app/src/main/java/org/opencb/opencga/app/migrations/v4/v4_0_0/catalog/JobModelChangesMigrationTask6445.java
@@ -19,15 +19,25 @@ public class JobModelChangesMigrationTask6445 extends MigrationTool {
 
     @Override
     protected void run() throws Exception {
-        Bson query = Filters.exists("type", false);
-        Bson update = Updates.combine(
-                Updates.set("type", "NATIVE"),
-                Updates.set("tool.minimumRequirements", new Document()),
-                Updates.set("execution.dependencies", Collections.emptyList())
+        Bson typeQuery = Filters.exists("type", false);
+        Bson typeUpdate = Updates.set("type", "NATIVE");
+
+        Bson requirementsQuery = Filters.and(
+                Filters.exists("tool.id"),
+                Filters.exists("tool.minimumRequirements", false)
+        );
+        Bson requirementsUpdate = Updates.set("tool.minimumRequirements", new Document());
+
+        Bson dependenciesQuery = Filters.and(
+                Filters.exists("execution.executor"),
+                Filters.exists("execution.dependencies", false)
         );
+        Bson dependenciesUpdate = Updates.set("execution.dependencies", Collections.emptyList());
         for (String collection : Arrays.asList(OrganizationMongoDBAdaptorFactory.JOB_COLLECTION,
                 OrganizationMongoDBAdaptorFactory.DELETED_JOB_COLLECTION)) {
-            getMongoCollection(collection).updateMany(query, update);
+            getMongoCollection(collection).updateMany(typeQuery, typeUpdate);
+            getMongoCollection(collection).updateMany(requirementsQuery, requirementsUpdate);
+            getMongoCollection(collection).updateMany(dependenciesQuery, dependenciesUpdate);
         }
     }
 

From 7a5b7cdcf0f58b442f328b882ba783fb19ff94f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jacobo=20Coll=20Morag=C3=B3n?= <jacobo167@gmail.com>
Date: Thu, 14 Nov 2024 10:34:23 +0000
Subject: [PATCH 99/99] master: Submit k8s job reading minRequirements
 #TASK-6445

---
 .../src/main/resources/configuration.yml      | 15 +-------
 .../opencga/core/common/IOUtilsTest.java      | 35 +++++++++++++++++++
 .../monitor/daemons/ExecutionDaemon.java      |  2 +-
 .../monitor/executors/AzureBatchExecutor.java | 16 +++++----
 .../monitor/executors/BatchExecutor.java      | 17 ++-------
 .../monitor/executors/ExecutorFactory.java    |  8 ++---
 .../master/monitor/executors/K8SExecutor.java | 29 +++++++++++++--
 .../monitor/executors/LocalExecutor.java      |  4 ++-
 .../master/monitor/executors/SGEExecutor.java |  5 +--
 .../monitor/daemons/ExecutionDaemonTest.java  |  6 ++--
 .../monitor/executors/LocalExecutorTest.java  |  5 +--
 11 files changed, 91 insertions(+), 51 deletions(-)

diff --git a/opencga-core/src/main/resources/configuration.yml b/opencga-core/src/main/resources/configuration.yml
index 29ff7bfb6a6..f7ebed9a5b9 100644
--- a/opencga-core/src/main/resources/configuration.yml
+++ b/opencga-core/src/main/resources/configuration.yml
@@ -104,7 +104,7 @@ analysis:
         HG38: "exomiser/2402_hg38.zip"
         PHENOTYPE: "exomiser/2402_phenotype.zip"
   execution:
-    # Accepted values are "local", "SGE", "azure-batch", "k8s"
+    # Accepted values are "local", "SGE", "k8s"
     # see org.opencb.opencga.master.monitor.executors.ExecutorFactory
     id: "${OPENCGA.EXECUTION.MODE}"
     defaultQueue: ""            # Default queue to be used to submit jobs
@@ -147,13 +147,6 @@ analysis:
         - "variant-secondary-sample-index"
       ## Local executor configuration
       local.maxConcurrentJobs: 2    # Max number of concurrent jobs to be executed locally in the master
-      ## Azure Batch Service configuration example
-      # azure.batchAccount : "batchAccount"
-      # azure.batchKey : "batchKey"
-      # azure.batchUri : "https://batchservice.uksouth.batch.azure.com"
-      # azure.batchPoolId : "poolId"
-      # azure.dockerImageName : "openCGADockerImageName"
-      # azure.dockerArgs : "dockerRunOptions"
 
       ## Kubernetes executor configuration example
       # k8s.masterUrl: "https://192.168.99.100:8443/"
@@ -181,12 +174,6 @@ analysis:
         agentpool: jobs
         kubernetes.io/os: linux
       # FOR ACI:
-      # k8s.requests:
-      #   cpu: 2
-      #   memory: "12G"
-      # k8s.limits:
-      #   cpu: 2
-      #   memory: "12G"
       # k8s.nodeSelector:
       #   kubernetes.io/role: agent
       #   kubernetes.io/os: linux
diff --git a/opencga-core/src/test/java/org/opencb/opencga/core/common/IOUtilsTest.java b/opencga-core/src/test/java/org/opencb/opencga/core/common/IOUtilsTest.java
index f8d85da1acf..dc7b3b4f482 100644
--- a/opencga-core/src/test/java/org/opencb/opencga/core/common/IOUtilsTest.java
+++ b/opencga-core/src/test/java/org/opencb/opencga/core/common/IOUtilsTest.java
@@ -16,6 +16,7 @@
 
 package org.opencb.opencga.core.common;
 
+import org.junit.Assert;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 import org.opencb.opencga.core.testclassification.duration.ShortTests;
@@ -25,6 +26,9 @@
 import java.io.InputStreamReader;
 import java.nio.file.Paths;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
 @Category(ShortTests.class)
 public class IOUtilsTest {
 
@@ -68,4 +72,35 @@ public void testGrepFile() throws Exception {
         in.close();
 
     }
+
+    @Test
+    public void fromHumanReadableToByte_ValidInput_ReturnsCorrectBytes() {
+        assertEquals(1024, IOUtils.fromHumanReadableToByte("1Ki"));
+        assertEquals(1024, IOUtils.fromHumanReadableToByte("1KiB"));
+        assertEquals(1024, IOUtils.fromHumanReadableToByte("1.KiB"));
+        assertEquals(1024, IOUtils.fromHumanReadableToByte("1.0KiB"));
+        assertEquals(1024, IOUtils.fromHumanReadableToByte("1.0K", true));
+        assertEquals(1024, IOUtils.fromHumanReadableToByte("1K", true));
+        assertEquals(1024, IOUtils.fromHumanReadableToByte("1KB", true));
+
+        assertEquals(1000, IOUtils.fromHumanReadableToByte("1K"));
+        assertEquals(1000, IOUtils.fromHumanReadableToByte("1KB"));
+    }
+
+    @Test
+    public void fromHumanReadableToByte_ValidInputWithBinaryUnits_ReturnsCorrectBytes() {
+        assertEquals(1048576, IOUtils.fromHumanReadableToByte("1Mi"));
+        assertEquals(1073741824, IOUtils.fromHumanReadableToByte("1Gi"));
+        assertEquals(1099511627776L, IOUtils.fromHumanReadableToByte("1Ti"));
+    }
+
+    @Test
+    public void fromHumanReadableToByte_InvalidInput_ThrowsNumberFormatException() {
+        assertThrows(NumberFormatException.class, () -> IOUtils.fromHumanReadableToByte("1X"));
+    }
+
+    @Test
+    public void fromHumanReadableToByte_NullInput_ThrowsNullPointerException() {
+        assertThrows(NullPointerException.class, () -> IOUtils.fromHumanReadableToByte(null));
+    }
 }
\ No newline at end of file
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
index caa63a6e8e4..02255368cca 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemon.java
@@ -660,7 +660,7 @@ protected int checkPendingJob(Job job) {
         try {
             String queue = getQueue(tool);
             logger.info("Queue job '{}' on queue '{}'", job.getId(), queue);
-            batchExecutor.execute(job.getId(), queue, authenticatedCommandLine, stdout, stderr);
+            batchExecutor.execute(job, queue, authenticatedCommandLine, stdout, stderr);
         } catch (Exception e) {
             return abortJob(job, "Error executing job.", e);
         }
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/AzureBatchExecutor.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/AzureBatchExecutor.java
index 28900481a81..2d3ebdfad59 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/AzureBatchExecutor.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/AzureBatchExecutor.java
@@ -24,12 +24,19 @@
 import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
-import java.nio.file.Path;
 
 /**
  * Created by wasim on 17/12/18.
+ *
+ *  ## Azure Batch Service configuration example
+ *  # azure.batchAccount : "batchAccount"
+ *  # azure.batchKey : "batchKey"
+ *  # azure.batchUri : "https://batchservice.uksouth.batch.azure.com"
+ *  # azure.batchPoolId : "poolId"
+ *  # azure.dockerImageName : "openCGADockerImageName"
+ *  # azure.dockerArgs : "dockerRunOptions"
  */
-public class AzureBatchExecutor implements BatchExecutor {
+public abstract class AzureBatchExecutor implements BatchExecutor {
 
     private String batchAccount;
     private String batchKey;
@@ -94,11 +101,6 @@ private BatchClient createBatchClient() {
         return BatchClient.open(new BatchSharedKeyCredentials(batchUri, batchAccount, batchKey));
     }
 
-    @Override
-    public void execute(String jobId, String queue, String commandLine, Path stdout, Path stderr) throws Exception {
-//        submitAzureTask(job, token);
-    }
-
     @Override
     public String getStatus(String jobId) {
         return null;
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/BatchExecutor.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/BatchExecutor.java
index 05c38e18545..c8f2217e5a2 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/BatchExecutor.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/BatchExecutor.java
@@ -16,6 +16,8 @@
 
 package org.opencb.opencga.master.monitor.executors;
 
+import org.opencb.opencga.core.models.job.Job;
+
 import java.io.Closeable;
 import java.nio.file.Path;
 
@@ -24,16 +26,7 @@
  */
 public interface BatchExecutor extends Closeable {
 
-    String TIMEOUT = "timeout";
-    String STDOUT = "stdout";
-    String STDERR = "stderr";
-    String OUTDIR = "outdir";
-    String NUM_THREADS = "num_threads";
-    String MAX_MEM = "max_mem";
-    String OUT_LOG_EXTENSION = ".log";
-    String ERR_LOG_EXTENSION = ".err";
-
-    void execute(String jobId, String queue, String commandLine, Path stdout, Path stderr) throws Exception;
+    void execute(Job job, String queue, String commandLine, Path stdout, Path stderr) throws Exception;
 
     String getStatus(String jobId);
 
@@ -49,10 +42,6 @@ default boolean canBeQueued() {
 
     boolean isExecutorAlive();
 
-    default String getCommandLine(String commandLine) {
-        return getCommandLine(commandLine, null, null);
-    }
-
     /**
      * We do it this way to avoid writing the session id in the command line (avoid display/monitor/logs) attribute of Job.
      * @param commandLine Basic command line
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/ExecutorFactory.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/ExecutorFactory.java
index 8fe26b8056e..6410c038e8e 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/ExecutorFactory.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/ExecutorFactory.java
@@ -40,10 +40,10 @@ public ExecutorFactory(Configuration configuration) {
             case "sge":
                 this.executor = new SGEExecutor(execution);
                 break;
-            case "azure":
-            case "azure-batch":
-                this.executor = new AzureBatchExecutor(execution);
-                break;
+//            case "azure":
+//            case "azure-batch":
+//                this.executor = new AzureBatchExecutor(execution);
+//                break;
             case "k8s":
             case "kubernetes":
                 this.executor = new K8SExecutor(configuration);
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/K8SExecutor.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/K8SExecutor.java
index b96dcf6f7e4..47f0ff50833 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/K8SExecutor.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/K8SExecutor.java
@@ -289,8 +289,10 @@ public void close() throws IOException {
     }
 
     @Override
-    public void execute(String jobId, String queue, String commandLine, Path stdout, Path stderr) throws Exception {
-        String jobName = buildJobName(jobId);
+    public void execute(org.opencb.opencga.core.models.job.Job job, String queue, String commandLine, Path stdout, Path stderr)
+            throws Exception {
+        String jobName = buildJobName(job.getId());
+        ResourceRequirements resources = getResources(job);
         final io.fabric8.kubernetes.api.model.batch.v1.Job k8sJob = new JobBuilder()
                 .withApiVersion("batch/v1")
                 .withKind("Job")
@@ -338,7 +340,28 @@ public void execute(String jobId, String queue, String commandLine, Path stdout,
             k8sJob.getSpec().getTemplate().getSpec().getContainers().add(dockerDaemonSidecar);
         }
         jobStatusCache.put(jobName, Pair.of(Instant.now(), Enums.ExecutionStatus.QUEUED));
-        getKubernetesClient().batch().jobs().inNamespace(namespace).create(k8sJob);
+        getKubernetesClient().batch().v1().jobs().inNamespace(namespace).resource(k8sJob).create();
+    }
+
+    private ResourceRequirements getResources(org.opencb.opencga.core.models.job.Job job) {
+        if (job.getTool().getMinimumRequirements() != null) {
+            ResourceRequirementsBuilder resources = new ResourceRequirementsBuilder(this.resources);
+            if (StringUtils.isNotEmpty(job.getTool().getMinimumRequirements().getMemory())) {
+                long memoryBytes = IOUtils.fromHumanReadableToByte(job.getTool().getMinimumRequirements().getMemory());
+                Quantity memory = new Quantity(String.valueOf(memoryBytes));
+                resources.addToRequests("memory", memory);
+                resources.addToLimits("memory", memory);
+            }
+            if (StringUtils.isNotEmpty(job.getTool().getMinimumRequirements().getCpu())) {
+                double cpuUnits = Double.parseDouble(job.getTool().getMinimumRequirements().getCpu());
+                Quantity cpu = new Quantity(Double.toString(cpuUnits));
+                resources.addToRequests("cpu", cpu);
+                resources.addToLimits("cpu", cpu);
+            }
+            return resources.build();
+        } else {
+            return this.resources;
+        }
     }
 
     private boolean shouldAddDockerDaemon(String queue) {
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/LocalExecutor.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/LocalExecutor.java
index 901dd7cb3c1..b63fa6442d4 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/LocalExecutor.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/LocalExecutor.java
@@ -20,6 +20,7 @@
 import org.opencb.commons.exec.RunnableProcess;
 import org.opencb.opencga.core.config.Execution;
 import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.job.Job;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -71,7 +72,8 @@ public void close() throws IOException {
     }
 
     @Override
-    public void execute(String jobId, String queue, String commandLine, Path stdout, Path stderr) throws Exception {
+    public void execute(Job job, String queue, String commandLine, Path stdout, Path stderr) throws Exception {
+        String jobId = job.getId();
         jobStatus.put(jobId, Enums.ExecutionStatus.QUEUED);
         Runnable runnable = () -> {
             try {
diff --git a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/SGEExecutor.java b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/SGEExecutor.java
index 0d0734deaca..be82993bfe2 100644
--- a/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/SGEExecutor.java
+++ b/opencga-master/src/main/java/org/opencb/opencga/master/monitor/executors/SGEExecutor.java
@@ -18,6 +18,7 @@
 
 import org.opencb.opencga.core.config.Execution;
 import org.opencb.opencga.core.models.common.Enums;
+import org.opencb.opencga.core.models.job.Job;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -42,8 +43,8 @@ public void close() throws IOException {
     }
 
     @Override
-    public void execute(String jobId, String queue, String commandLine, Path stdout, Path stderr) throws Exception {
-        sgeManager.queueJob(jobId, "", -1, getCommandLine(commandLine, stdout, stderr), null);
+    public void execute(Job job, String queue, String commandLine, Path stdout, Path stderr) throws Exception {
+        sgeManager.queueJob(job.getId(), "", -1, getCommandLine(commandLine, stdout, stderr), null);
     }
 
     @Override
diff --git a/opencga-master/src/test/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemonTest.java b/opencga-master/src/test/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemonTest.java
index 18fae2390f5..359a2fc818d 100644
--- a/opencga-master/src/test/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemonTest.java
+++ b/opencga-master/src/test/java/org/opencb/opencga/master/monitor/daemons/ExecutionDaemonTest.java
@@ -710,9 +710,9 @@ private static class DummyBatchExecutor implements BatchExecutor {
         public Map<String, String> jobStatus = new HashMap<>();
 
         @Override
-        public void execute(String jobId, String queue, String commandLine, Path stdout, Path stderr) throws Exception {
-            System.out.println("Executing job " + jobId + " --- " + commandLine);
-            jobStatus.put(jobId, Enums.ExecutionStatus.QUEUED);
+        public void execute(Job job, String queue, String commandLine, Path stdout, Path stderr) throws Exception {
+            System.out.println("Executing job " + job.getId() + " --- " + commandLine);
+            jobStatus.put(job.getId(), Enums.ExecutionStatus.QUEUED);
         }
 
         @Override
diff --git a/opencga-master/src/test/java/org/opencb/opencga/master/monitor/executors/LocalExecutorTest.java b/opencga-master/src/test/java/org/opencb/opencga/master/monitor/executors/LocalExecutorTest.java
index a350fdc3c77..1830c0fc987 100644
--- a/opencga-master/src/test/java/org/opencb/opencga/master/monitor/executors/LocalExecutorTest.java
+++ b/opencga-master/src/test/java/org/opencb/opencga/master/monitor/executors/LocalExecutorTest.java
@@ -22,6 +22,7 @@
 import org.junit.experimental.categories.Category;
 import org.opencb.commons.datastore.core.ObjectMap;
 import org.opencb.opencga.core.config.Execution;
+import org.opencb.opencga.core.models.job.Job;
 import org.opencb.opencga.core.testclassification.duration.ShortTests;
 
 import java.nio.file.Files;
@@ -53,7 +54,7 @@ public void setUp() throws Exception {
     public void test() throws Exception {
         System.out.println(rootDir.toAbsolutePath());
         for (int i = 0; i < 10; i++) {
-            localExecutor.execute("jobId-" + i, "default", "echo Hello World", rootDir.resolve("out_" + i + ".txt"), rootDir.resolve("err_" + i + ".txt"));
+            localExecutor.execute(new Job().setId("jobId-" + i), "default", "echo Hello World", rootDir.resolve("out_" + i + ".txt"), rootDir.resolve("err_" + i + ".txt"));
         }
 
         for (int i = 0; i < 10; i++) {
@@ -73,7 +74,7 @@ public void testKill() throws Exception {
         System.out.println(rootDir.toAbsolutePath());
         for (int i = 0; i < 10; i++) {
 //            System.out.println("Submitting job " + i);
-            localExecutor.execute("jobId-" + i, "default", "sleep 20", rootDir.resolve("out_" + i + ".txt"), rootDir.resolve("err_" + i + ".txt"));
+            localExecutor.execute(new Job().setId("jobId-" + i), "default", "sleep 20", rootDir.resolve("out_" + i + ".txt"), rootDir.resolve("err_" + i + ".txt"));
         }
 
         // Allow some time for the jobs to start