From c22fe91499b4e200b4a856856f216e73b2cb9ddb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lo=C3=AFc=20Mathieu?= <loikeseke@gmail.com>
Date: Tue, 14 Feb 2023 10:18:07 +0100
Subject: [PATCH 1/9] feat: extract flows and templates

---
 .../FlowNamespaceExtractCommand.java          | 54 ++++++++++++++++
 .../TemplateNamespaceExtractCommand.java      | 63 ++++++++++++++++++
 .../FlowNamespaceExtractCommandTest.java      | 63 ++++++++++++++++++
 .../TemplateNamespaceExtractCommandTest.java  | 64 +++++++++++++++++++
 .../core/models/templates/Template.java       | 33 ++++++++++
 .../repositories/FlowRepositoryInterface.java |  6 ++
 .../TemplateRepositoryInterface.java          |  6 ++
 .../AbstractFlowRepositoryTest.java           | 19 ++++++
 .../AbstractTemplateRepositoryTest.java       | 26 ++++++++
 .../AbstractJdbcFlowRepository.java           | 27 ++++++++
 .../AbstractJdbcTemplateRepository.java       | 27 ++++++++
 .../memory/MemoryFlowRepository.java          | 26 +++++++-
 .../memory/MemoryTemplateRepository.java      | 12 +++-
 .../memory/MemoryFlowRepositoryTest.java      | 10 +++
 .../webserver/controllers/FlowController.java | 60 +++++++++++++++++
 .../controllers/TemplateController.java       | 59 ++++++++++++++++-
 .../controllers/FlowControllerTest.java       | 31 +++++++++
 .../controllers/TemplateControllerTest.java   | 47 +++++++++++++-
 18 files changed, 627 insertions(+), 6 deletions(-)
 create mode 100644 cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java
 create mode 100644 cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java
 create mode 100644 cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommandTest.java
 create mode 100644 cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommandTest.java

diff --git a/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java b/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java
new file mode 100644
index 00000000000..37356ce3c5f
--- /dev/null
+++ b/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java
@@ -0,0 +1,54 @@
+package io.kestra.cli.commands.flows.namespaces;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.commands.flows.FlowValidateCommand;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.HttpResponse;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@CommandLine.Command(
+    name = "extract",
+    description = "extract namespace flows",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class FlowNamespaceExtractCommand extends AbstractApiCommand {
+    private static final String DEFAULT_FILE_NAME = "flows.zip";
+
+    @CommandLine.Parameters(index = "0", description = "the namespace of templates to extract")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "1", description = "the directory to extract the file to")
+    public Path directory;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        try(DefaultHttpClient client = client()) {
+            MutableHttpRequest<Object> request = HttpRequest
+                .GET("/api/v1/flows/extract/by_query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
+
+            HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
+            Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
+            zipFile.toFile().createNewFile();
+            Files.write(zipFile, response.body());
+
+            stdOut("Extracted flow(s) for namespace '" + namespace + "' successfully done !");
+        } catch (HttpClientResponseException e) {
+            FlowValidateCommand.handleHttpException(e, "flow");
+            return 1;
+        }
+
+        return 0;
+    }
+
+}
diff --git a/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java b/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java
new file mode 100644
index 00000000000..088b84b530a
--- /dev/null
+++ b/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java
@@ -0,0 +1,63 @@
+package io.kestra.cli.commands.templates.namespaces;
+
+import io.kestra.cli.AbstractApiCommand;
+import io.kestra.cli.commands.AbstractServiceNamespaceUpdateCommand;
+import io.kestra.cli.commands.flows.FlowValidateCommand;
+import io.kestra.cli.commands.templates.TemplateValidateCommand;
+import io.kestra.core.models.templates.Template;
+import io.kestra.core.serializers.YamlFlowParser;
+import io.micronaut.core.type.Argument;
+import io.micronaut.http.HttpRequest;
+import io.micronaut.http.HttpResponse;
+import io.micronaut.http.MediaType;
+import io.micronaut.http.MutableHttpRequest;
+import io.micronaut.http.client.exceptions.HttpClientResponseException;
+import io.micronaut.http.client.netty.DefaultHttpClient;
+import jakarta.inject.Inject;
+import lombok.extern.slf4j.Slf4j;
+import picocli.CommandLine;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.validation.ConstraintViolationException;
+
+@CommandLine.Command(
+    name = "extract",
+    description = "extract namespace templates",
+    mixinStandardHelpOptions = true
+)
+@Slf4j
+public class TemplateNamespaceExtractCommand extends AbstractApiCommand {
+    private static final String DEFAULT_FILE_NAME = "templates.zip";
+
+    @CommandLine.Parameters(index = "0", description = "the namespace of templates to extract")
+    public String namespace;
+
+    @CommandLine.Parameters(index = "1", description = "the directory to extract the file to")
+    public Path directory;
+
+    @Override
+    public Integer call() throws Exception {
+        super.call();
+
+        try(DefaultHttpClient client = client()) {
+            MutableHttpRequest<Object> request = HttpRequest
+                .GET("/api/v1/templates/extract/by_query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
+
+            HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
+            Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
+            zipFile.toFile().createNewFile();
+            Files.write(zipFile, response.body());
+
+            stdOut("Extracted template(s) for namespace '" + namespace + "' successfully done !");
+        } catch (HttpClientResponseException e) {
+            TemplateValidateCommand.handleHttpException(e, "template");
+            return 1;
+        }
+
+        return 0;
+    }
+
+}
diff --git a/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommandTest.java b/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommandTest.java
new file mode 100644
index 00000000000..92a5db02d69
--- /dev/null
+++ b/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommandTest.java
@@ -0,0 +1,63 @@
+package io.kestra.cli.commands.flows.namespaces;
+
+import io.micronaut.configuration.picocli.PicocliRunner;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.env.Environment;
+import io.micronaut.runtime.server.EmbeddedServer;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.net.URL;
+import java.util.zip.ZipFile;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.StringContains.containsString;
+
+class FlowNamespaceExtractCommandTest {
+    @Test
+    void run() throws IOException {
+        URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows");
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            // we use the update command to add flows to extract
+            String[] updateArgs = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "io.kestra.cli",
+                directory.getPath(),
+
+            };
+            PicocliRunner.call(FlowNamespaceUpdateCommand.class, ctx, updateArgs);
+            assertThat(out.toString(), containsString("3 flow(s)"));
+
+            // then we extract them
+            String[] extractArgs = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "io.kestra.cli",
+                "/tmp",
+            };
+            PicocliRunner.call(FlowNamespaceExtractCommand.class, ctx, extractArgs);
+            File file = new File("/tmp/flows.zip");
+            assertThat(file.exists(), is(true));
+            ZipFile zipFile = new ZipFile(file);
+            assertThat(zipFile.stream().count(), is(3L));
+
+            file.delete();
+        }
+    }
+}
\ No newline at end of file
diff --git a/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommandTest.java b/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommandTest.java
new file mode 100644
index 00000000000..9e1b9f6012a
--- /dev/null
+++ b/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommandTest.java
@@ -0,0 +1,64 @@
+package io.kestra.cli.commands.templates.namespaces;
+
+import io.micronaut.configuration.picocli.PicocliRunner;
+import io.micronaut.context.ApplicationContext;
+import io.micronaut.context.env.Environment;
+import io.micronaut.runtime.server.EmbeddedServer;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.net.URL;
+import java.util.zip.ZipFile;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.StringContains.containsString;
+import static org.hamcrest.core.Is.is;
+
+class TemplateNamespaceExtractCommandTest {
+    @Test
+    void run() throws IOException {
+        URL directory = TemplateNamespaceExtractCommandTest.class.getClassLoader().getResource("templates");
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(out));
+
+        try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
+
+            EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
+            embeddedServer.start();
+
+            // we use the update command to add templates to extract
+            String[] args = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "io.kestra.tests",
+                directory.getPath(),
+
+            };
+            PicocliRunner.call(TemplateNamespaceUpdateCommand.class, ctx, args);
+            assertThat(out.toString(), containsString("3 template(s)"));
+
+            // then we extract them
+            String[] extractArgs = {
+                "--server",
+                embeddedServer.getURL().toString(),
+                "--user",
+                "myuser:pass:word",
+                "io.kestra.tests",
+                "/tmp",
+            };
+            PicocliRunner.call(TemplateNamespaceExtractCommand.class, ctx, extractArgs);
+            File file = new File("/tmp/templates.zip");
+            assertThat(file.exists(), is(true));
+            ZipFile zipFile = new ZipFile(file);
+            assertThat(zipFile.stream().count(), is(3L));
+
+            file.delete();
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/core/src/main/java/io/kestra/core/models/templates/Template.java b/core/src/main/java/io/kestra/core/models/templates/Template.java
index 573a49e6c83..85f5e7c4c94 100644
--- a/core/src/main/java/io/kestra/core/models/templates/Template.java
+++ b/core/src/main/java/io/kestra/core/models/templates/Template.java
@@ -1,9 +1,15 @@
 package io.kestra.core.models.templates;
 
 import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
+import com.fasterxml.jackson.databind.introspect.JacksonAnnotationIntrospector;
 import io.kestra.core.models.DeletedInterface;
 import io.kestra.core.models.tasks.Task;
 import io.kestra.core.models.validations.ManualConstraintViolation;
+import io.kestra.core.serializers.JacksonMapper;
 import io.micronaut.core.annotation.Introspected;
 import lombok.*;
 import lombok.experimental.SuperBuilder;
@@ -25,6 +31,16 @@
 @ToString
 @EqualsAndHashCode
 public class Template implements DeletedInterface {
+
+    private static final ObjectMapper jsonMapper = JacksonMapper.ofJson().copy()
+        .setAnnotationIntrospector(new JacksonAnnotationIntrospector() {
+            @Override
+            public boolean hasIgnoreMarker(final AnnotatedMember m) {
+                List<String> exclusions = Arrays.asList("revision", "deleted", "source");
+                return exclusions.contains(m.getName()) || super.hasIgnoreMarker(m);
+            }
+        });
+
     @NotNull
     @NotBlank
     @Pattern(regexp = "[a-zA-Z0-9._-]+")
@@ -93,6 +109,23 @@ public Optional<ConstraintViolationException> validateUpdate(Template updated) {
         }
     }
 
+    public String generateSource() {
+        try {
+            return JacksonMapper.ofYaml()
+                .writeValueAsString(
+                    JacksonMapper
+                        .ofJson()
+                        .readTree(
+                            jsonMapper.copy()
+                                .setSerializationInclusion(JsonInclude.Include.NON_DEFAULT)
+                                .writeValueAsString(this)
+                        )
+                );
+        } catch (JsonProcessingException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     public Template toDeleted() {
         return new Template(
             this.id,
diff --git a/core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java b/core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java
index 1dafc129cc5..689be4eb01b 100644
--- a/core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java
+++ b/core/src/main/java/io/kestra/core/repositories/FlowRepositoryInterface.java
@@ -55,6 +55,12 @@ ArrayListTotal<Flow> find(
         @Nullable Map<String, String> labels
     );
 
+    List<FlowWithSource> findWithSource(
+        @Nullable String query,
+        @Nullable String namespace,
+        @Nullable Map<String, String> labels
+    );
+
     ArrayListTotal<SearchResult<Flow>> findSourceCode(Pageable pageable, @Nullable String query, @Nullable String namespace);
 
     List<String> findDistinctNamespace();
diff --git a/core/src/main/java/io/kestra/core/repositories/TemplateRepositoryInterface.java b/core/src/main/java/io/kestra/core/repositories/TemplateRepositoryInterface.java
index c88baff4b10..5731eb30822 100644
--- a/core/src/main/java/io/kestra/core/repositories/TemplateRepositoryInterface.java
+++ b/core/src/main/java/io/kestra/core/repositories/TemplateRepositoryInterface.java
@@ -18,6 +18,12 @@ ArrayListTotal<Template> find(
         @Nullable String namespace
     );
 
+    // Should normally be TemplateWithSource but it didn't exist yet
+    List<Template> find(
+        @Nullable String query,
+        @Nullable String namespace
+    );
+
     List<Template> findByNamespace(String namespace);
 
     Template create(Template template);
diff --git a/core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java b/core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java
index 96de5db3575..f1443d37df4 100644
--- a/core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java
+++ b/core/src/test/java/io/kestra/core/repositories/AbstractFlowRepositoryTest.java
@@ -19,6 +19,7 @@
 import io.kestra.core.utils.IdUtils;
 import io.kestra.core.utils.TestsUtils;
 import io.micronaut.context.event.ApplicationEventListener;
+import io.micronaut.data.model.Pageable;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
 import jakarta.inject.Inject;
 import jakarta.inject.Named;
@@ -216,6 +217,24 @@ void findByNamespace() {
         assertThat((long) save.size(), is(1L));
     }
 
+    @Test
+    void find() {
+        List<Flow> save = flowRepository.find(Pageable.from(1, 10),null, "io.kestra.tests", Collections.emptyMap());
+        assertThat((long) save.size(), is(10L));
+
+        save = flowRepository.find(Pageable.from(1),null, "io.kestra.tests.minimal.bis", Collections.emptyMap());
+        assertThat((long) save.size(), is(1L));
+    }
+
+    @Test
+    void findWithSource() {
+        List<FlowWithSource> save = flowRepository.findWithSource(null, "io.kestra.tests", Collections.emptyMap());
+        assertThat((long) save.size(), is(Helpers.FLOWS_COUNT));
+
+        save = flowRepository.findWithSource(null, "io.kestra.tests.minimal.bis", Collections.emptyMap());
+        assertThat((long) save.size(), is(1L));
+    }
+
     @Test
     void delete() {
         Flow flow = builder().build();
diff --git a/core/src/test/java/io/kestra/core/repositories/AbstractTemplateRepositoryTest.java b/core/src/test/java/io/kestra/core/repositories/AbstractTemplateRepositoryTest.java
index 31d5534fa15..c1184a48da5 100644
--- a/core/src/test/java/io/kestra/core/repositories/AbstractTemplateRepositoryTest.java
+++ b/core/src/test/java/io/kestra/core/repositories/AbstractTemplateRepositoryTest.java
@@ -1,11 +1,15 @@
 package io.kestra.core.repositories;
 
+import io.kestra.core.Helpers;
 import io.kestra.core.events.CrudEvent;
 import io.kestra.core.events.CrudEventType;
+import io.kestra.core.models.flows.Flow;
+import io.kestra.core.models.flows.FlowWithSource;
 import io.kestra.core.models.templates.Template;
 import io.kestra.core.tasks.debugs.Return;
 import io.kestra.core.utils.IdUtils;
 import io.micronaut.context.event.ApplicationEventListener;
+import io.micronaut.data.model.Pageable;
 import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
 import jakarta.inject.Inject;
 import jakarta.inject.Singleton;
@@ -91,6 +95,28 @@ void findAll() {
         assertThat((long) templateRepository.findAll().size(), is(saveCount));
     }
 
+    @Test
+    void find() {
+        Template template1 = builder().build();
+        templateRepository.create(template1);
+        Template template2 = builder().build();
+        templateRepository.create(template2);
+        Template template3 = builder().build();
+        templateRepository.create(template3);
+
+        // with pageable
+        List<Template> save = templateRepository.find(Pageable.from(1, 10),null, "kestra.test");
+        assertThat((long) save.size(), greaterThanOrEqualTo(3L));
+
+        // without pageable
+        save = templateRepository.find(null, "kestra.test");
+        assertThat((long) save.size(), greaterThanOrEqualTo(3L));
+
+        templateRepository.delete(template1);
+        templateRepository.delete(template2);
+        templateRepository.delete(template3);
+    }
+
     @Test
     void delete() {
         Template template = builder().build();
diff --git a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java
index e3e1ea23eef..1613cc730e7 100644
--- a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java
+++ b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcFlowRepository.java
@@ -239,6 +239,33 @@ public ArrayListTotal<Flow> find(
             });
     }
 
+    @Override
+    public List<FlowWithSource> findWithSource(
+        @Nullable String query,
+        @Nullable String namespace,
+        @Nullable Map<String, String> labels
+    ) {
+        return this.jdbcRepository
+            .getDslContextWrapper()
+            .transactionResult(configuration -> {
+                DSLContext context = DSL.using(configuration);
+                List<Field<Object>> fields = List.of(field("value"), field("source_code"));
+                SelectConditionStep<Record> select = this.fullTextSelect(context, fields);
+
+                select.and(this.findCondition(query, labels));
+
+                if (namespace != null) {
+                    select.and(field("namespace").likeIgnoreCase(namespace + "%"));
+                }
+
+                return select.fetch().map(record -> FlowWithSource.of(
+                    jdbcRepository.map(record),
+                    record.get("source_code", String.class)
+                ));
+            });
+    }
+
+
     abstract protected Condition findSourceCodeCondition(String query);
 
     @Override
diff --git a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcTemplateRepository.java b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcTemplateRepository.java
index 083348af9a7..7ebf923b5f6 100644
--- a/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcTemplateRepository.java
+++ b/jdbc/src/main/java/io/kestra/jdbc/repository/AbstractJdbcTemplateRepository.java
@@ -97,6 +97,33 @@ public ArrayListTotal<Template> find(
             });
     }
 
+    @Override
+    public List<Template> find(@Nullable String query, @Nullable String namespace) {
+        return this.jdbcRepository
+            .getDslContextWrapper()
+            .transactionResult(configuration -> {
+                DSLContext context = DSL.using(configuration);
+
+                SelectConditionStep<Record1<Object>> select = context
+                    .select(
+                        field("value")
+                    )
+                    .hint(configuration.dialect() == SQLDialect.MYSQL ? "SQL_CALC_FOUND_ROWS" : null)
+                    .from(this.jdbcRepository.getTable())
+                    .where(this.defaultFilter());
+
+                if (query != null) {
+                    select.and(this.findCondition(query));
+                }
+
+                if (namespace != null) {
+                    select.and(field("namespace").likeIgnoreCase(namespace + "%"));
+                }
+
+                return this.jdbcRepository.fetch(select);
+            });
+    }
+
     @Override
     public List<Template> findByNamespace(String namespace) {
         return this.jdbcRepository
diff --git a/repository-memory/src/main/java/io/kestra/repository/memory/MemoryFlowRepository.java b/repository-memory/src/main/java/io/kestra/repository/memory/MemoryFlowRepository.java
index c6207b54091..5f3db194421 100644
--- a/repository-memory/src/main/java/io/kestra/repository/memory/MemoryFlowRepository.java
+++ b/repository-memory/src/main/java/io/kestra/repository/memory/MemoryFlowRepository.java
@@ -17,6 +17,7 @@
 import io.kestra.core.repositories.ArrayListTotal;
 import io.kestra.core.repositories.FlowRepositoryInterface;
 import io.kestra.core.services.FlowService;
+import io.reactivex.Flowable;
 import org.apache.commons.lang3.NotImplementedException;
 
 import jakarta.inject.Inject;
@@ -80,6 +81,7 @@ private Optional<String> findSourceById(String namespace, String id) {
             Optional.empty();
     }
 
+    @Override
     public Optional<FlowWithSource> findByIdWithSource(String namespace, String id, Optional<Integer> revision) {
         Optional<Flow> flow = findById(namespace, id, revision);
         Optional<String> sourceCode = findSourceById(namespace, id);
@@ -115,18 +117,38 @@ public List<Flow> findByNamespace(String namespace) {
             .collect(Collectors.toList());
     }
 
+    @Override
     public ArrayListTotal<Flow> find(
         Pageable pageable,
         @Nullable String query,
         @Nullable String namespace,
         @Nullable Map<String, String> labels
     ) {
-        //TODO Non used query, returns just all at the moment
         if (pageable.getNumber() < 1) {
             throw new ValueException("Page cannot be < 1");
         }
 
-        return ArrayListTotal.of(pageable, this.findAll());
+        //TODO Non used query, just returns all flow and filter by namespace if set
+        List<Flow> results = flows.values()
+            .stream()
+            .filter(flow -> namespace == null || flow.getNamespace().startsWith(namespace))
+            .collect(Collectors.toList());
+        return ArrayListTotal.of(pageable, results);
+    }
+
+    @Override
+    public List<FlowWithSource> findWithSource(
+        @Nullable String query,
+        @Nullable String namespace,
+        @Nullable Map<String, String> labels
+    ) {
+        //TODO Non used query, just returns all flow and filter by namespace if set
+        return flows.values()
+            .stream()
+            .filter(flow -> namespace == null || flow.getNamespace().startsWith(namespace))
+            .sorted(Comparator.comparingInt(Flow::getRevision))
+            .map(flow -> findByIdWithSource(flow.getNamespace(), flow.getId(), Optional.of(flow.getRevision())).get())
+            .collect(Collectors.toList());
     }
 
     @Override
diff --git a/repository-memory/src/main/java/io/kestra/repository/memory/MemoryTemplateRepository.java b/repository-memory/src/main/java/io/kestra/repository/memory/MemoryTemplateRepository.java
index fe9118baaae..f44ade448e9 100644
--- a/repository-memory/src/main/java/io/kestra/repository/memory/MemoryTemplateRepository.java
+++ b/repository-memory/src/main/java/io/kestra/repository/memory/MemoryTemplateRepository.java
@@ -1,6 +1,8 @@
 package io.kestra.repository.memory;
 
+import io.kestra.core.models.flows.Flow;
 import io.micronaut.context.event.ApplicationEventPublisher;
+import io.micronaut.core.annotation.Nullable;
 import io.micronaut.core.value.ValueException;
 import io.micronaut.data.model.Pageable;
 import io.kestra.core.events.CrudEvent;
@@ -48,11 +50,19 @@ public ArrayListTotal<Template> find(Pageable pageable, String query, String nam
             throw new ValueException("Page cannot be < 1");
         }
 
-        List<Template> filteredTemplates = new ArrayList<>(templates.values());
+        List<Template> filteredTemplates = find(query, namespace);
 
         return ArrayListTotal.of(pageable, filteredTemplates);
     }
 
+    @Override
+    public List<Template> find(@Nullable String query, @Nullable String namespace) {
+        return templates.values()
+            .stream()
+            .filter(flow -> namespace == null || flow.getNamespace().equals(namespace))
+            .collect(Collectors.toList());
+    }
+
     @Override
     public List<Template> findByNamespace(String namespace) {
         return templates.values()
diff --git a/repository-memory/src/test/java/io/kestra/repository/memory/MemoryFlowRepositoryTest.java b/repository-memory/src/test/java/io/kestra/repository/memory/MemoryFlowRepositoryTest.java
index 79bade530d9..8ed215095eb 100644
--- a/repository-memory/src/test/java/io/kestra/repository/memory/MemoryFlowRepositoryTest.java
+++ b/repository-memory/src/test/java/io/kestra/repository/memory/MemoryFlowRepositoryTest.java
@@ -4,10 +4,20 @@
 import io.kestra.core.repositories.AbstractFlowRepositoryTest;
 
 import jakarta.inject.Inject;
+import org.junit.jupiter.api.BeforeEach;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
 
 @MicronautTest
 public class MemoryFlowRepositoryTest extends AbstractFlowRepositoryTest {
 
     @Inject
     MemoryFlowRepository memoryFlowRepository;
+
+    @BeforeEach
+    protected void init() throws IOException, URISyntaxException {
+        memoryFlowRepository.findAll().forEach(flow -> memoryFlowRepository.delete(flow));
+        super.init();
+    }
 }
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
index 4591cc83cab..26a09a199c1 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
@@ -36,11 +36,15 @@
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import jakarta.inject.Inject;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
 import javax.validation.ConstraintViolationException;
 import javax.validation.Valid;
 
@@ -149,6 +153,7 @@ public PagedResults<Flow> find(
         ));
     }
 
+
     @ExecuteOn(TaskExecutors.IO)
     @Get(uri = "/source", produces = MediaType.TEXT_JSON)
     @Operation(tags = {"Flows"}, summary = "Search for flows source code")
@@ -444,4 +449,59 @@ public List<ValidateConstraintViolation> validateFlows(
             })
             .collect(Collectors.toList());
     }
+
+    @ExecuteOn(TaskExecutors.IO)
+    @Get(uri = "/extract/by_query", produces = MediaType.APPLICATION_OCTET_STREAM)
+    @Operation(
+        tags = {"Flows"},
+        summary = "Extract flows as a ZIP archive of yaml sources."
+    )
+    public HttpResponse<byte[]> extractByQuery(
+        @Parameter(description = "A string filter") @Nullable @QueryValue(value = "q") String query,
+        @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue(value = "namespace") String namespace,
+        @Parameter(description = "A labels filter") @Nullable @QueryValue List<String> labels
+    ) throws IOException {
+        try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            ZipOutputStream archive = new ZipOutputStream(bos)) {
+
+            List<FlowWithSource> toExtract = flowRepository.findWithSource(query, namespace, RequestUtils.toMap(labels));
+            for(var flowWithSource : toExtract) {
+                var zipEntry = new ZipEntry(flowWithSource.getNamespace() + "-" + flowWithSource.getId() + ".yml");
+                archive.putNextEntry(zipEntry);
+                archive.write(flowWithSource.getSource().getBytes());
+                archive.closeEntry();
+            }
+
+            archive.finish();
+            return HttpResponse.ok(bos.toByteArray())
+                .header("Content-Disposition", "attachment; filename=\"flows.zip\"");
+        }
+    }
+
+    @ExecuteOn(TaskExecutors.IO)
+    @Post(uri = "/extract/by_ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
+    @Operation(
+        tags = {"Flows"},
+        summary = "Extract flows as a ZIP archive of yaml sources."
+    )
+    public HttpResponse<byte[]> extractByIds(
+        @Parameter(description = "A namespace filter prefix") @QueryValue(value = "namespace") String namespace,
+        @Parameter(description = "A list of string identifiers") @Body List<String> ids
+    ) throws IOException {
+        try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            ZipOutputStream archive = new ZipOutputStream(bos)) {
+
+            for(var id : ids) {
+                FlowWithSource flowWithSource = flowRepository.findByIdWithSource(namespace, id).orElseThrow();
+                var zipEntry = new ZipEntry(flowWithSource.getNamespace() + "-" + flowWithSource.getId() + ".yml");
+                archive.putNextEntry(zipEntry);
+                archive.write(flowWithSource.getSource().getBytes());
+                archive.closeEntry();
+            }
+
+            archive.finish();
+            return HttpResponse.ok(bos.toByteArray())
+                .header("Content-Disposition", "attachment; filename=\"flows.zip\"");
+        }
+    }
 }
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
index 543d0e6639b..a4983049f5d 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
@@ -23,11 +23,14 @@
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import jakarta.inject.Inject;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
 import javax.validation.ConstraintViolationException;
 import javax.validation.Valid;
 
@@ -218,6 +221,7 @@ private List<Template> updateCompleteNamespace(String namespace, List<Template>
         return Stream.concat(deleted.stream(), updatedOrCreated.stream()).collect(Collectors.toList());
     }
 
+
     @ExecuteOn(TaskExecutors.IO)
     @Post(uri = "validate", produces = MediaType.TEXT_JSON, consumes = MediaType.APPLICATION_YAML)
     @Operation(tags = {"Templates"}, summary = "Validate a list of templates")
@@ -244,4 +248,57 @@ public List<ValidateConstraintViolation> validateTemplates(
             })
             .collect(Collectors.toList());
     }
+
+    @ExecuteOn(TaskExecutors.IO)
+    @Get(uri = "/extract/by_query", produces = MediaType.APPLICATION_OCTET_STREAM)
+    @Operation(
+        summary = "Extract templates as a ZIP archive of yaml sources."
+    )
+    public HttpResponse<byte[]> extractByQuery(
+        @Parameter(description = "A string filter") @Nullable @QueryValue(value = "q") String query,
+        @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue(value = "namespace") String namespace
+    ) throws IOException {
+        try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            ZipOutputStream archive = new ZipOutputStream(bos)) {
+
+            List<Template> toExtract = templateRepository.find(query, namespace);
+            System.out.println(toExtract.size());
+            for(var template : toExtract) {
+                var zipEntry = new ZipEntry(template.getNamespace() + "-" + template.getId() + ".yml");
+                archive.putNextEntry(zipEntry);
+                archive.write(template.generateSource().getBytes());
+                archive.closeEntry();
+            }
+
+            archive.finish();
+            return HttpResponse.ok(bos.toByteArray())
+                .header("Content-Disposition", "attachment; filename=\"templates.zip\"");
+        }
+    }
+
+    @ExecuteOn(TaskExecutors.IO)
+    @Post(uri = "/extract/by_ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
+    @Operation(
+        summary = "Extract templates as a ZIP archive of yaml sources."
+    )
+    public HttpResponse<byte[]> extractByIds(
+        @Parameter(description = "A namespace filter prefix") @QueryValue(value = "namespace") String namespace,
+        @Parameter(description = "A list of string identifiers") @Body List<String> ids
+    ) throws IOException {
+        try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
+            ZipOutputStream archive = new ZipOutputStream(bos)) {
+
+            for(var id : ids) {
+                var template = templateRepository.findById(namespace, id).orElseThrow();
+                var zipEntry = new ZipEntry(template.getNamespace() + "-" + template.getId() + ".yml");
+                archive.putNextEntry(zipEntry);
+                archive.write(template.generateSource().getBytes());
+                archive.closeEntry();
+            }
+
+            archive.finish();
+            return HttpResponse.ok(bos.toByteArray())
+                .header("Content-Disposition", "attachment; filename=\"templates.zip\"");
+        }
+    }
 }
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
index f788b9e16e8..ff0cd9c9a4f 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
@@ -26,6 +26,7 @@
 import io.kestra.core.utils.IdUtils;
 import io.kestra.webserver.responses.PagedResults;
 
+import java.io.File;
 import java.io.IOException;
 import java.net.URL;
 import java.nio.charset.Charset;
@@ -35,6 +36,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.zip.ZipFile;
 
 import jakarta.inject.Inject;
 
@@ -453,6 +455,35 @@ void updateInvalidFlowFromString() throws IOException {
         assertThat(jsonError, containsString("flow.namespace"));
     }
 
+    @Test
+    void extractByQuery() throws IOException {
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/flows/extract/by_query?namespace=io.kestra.tests"),
+            Argument.of(byte[].class));
+        File file = File.createTempFile("flows", ".zip");
+        Files.write(file.toPath(), zip);
+
+        try (ZipFile zipFile = new ZipFile(file)) {
+            assertThat(zipFile.stream().count(), is(52L));
+        }
+
+        file.delete();
+    }
+
+    @Test
+    void extractByIds() throws IOException {
+        List<String> ids = List.of("each-object", "webhook", "task-flow");
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/flows/extract/by_ids?namespace=io.kestra.tests", ids),
+            Argument.of(byte[].class));
+        File file = File.createTempFile("flows", ".zip");
+        Files.write(file.toPath(), zip);
+
+        try(ZipFile zipFile = new ZipFile(file)) {
+            assertThat(zipFile.stream().count(), is(3L));
+        }
+
+        file.delete();
+    }
+
     private Flow generateFlow(String namespace, String inputName) {
         return generateFlow(IdUtils.create(), namespace, inputName);
     }
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
index 050faff8e85..0360820d7b4 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
@@ -15,8 +15,13 @@
 import io.kestra.core.utils.IdUtils;
 import io.kestra.webserver.responses.PagedResults;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
 import java.util.Arrays;
 import java.util.List;
+import java.util.zip.ZipFile;
+
 import jakarta.inject.Inject;
 
 import static io.micronaut.http.HttpRequest.*;
@@ -30,8 +35,6 @@ class TemplateControllerTest extends AbstractMemoryRunnerTest {
     @Client("/")
     RxHttpClient client;
 
-    public static final String TESTS_FLOW_NS = "io.kestra.tests";
-
     private Template createTemplate() {
         Task t1 = Return.builder().id("task-1").type(Return.class.getName()).format("test").build();
         Task t2 = Return.builder().id("task-2").type(Return.class.getName()).format("test").build();
@@ -123,4 +126,44 @@ void listDistinctNamespace() {
 
         assertThat(namespaces.size(), is(2));
     }
+
+    @Test
+    void extractByQuery() throws IOException {
+        // create 3 templates, so we have at least 3 of them
+        client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
+        client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
+        client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
+        int size = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/templates/search?namespace=kestra.test"), Argument.of(PagedResults.class, Template.class)).getResults().size();
+
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/templates/extract/by_query?namespace=kestra.test"),
+            Argument.of(byte[].class));
+        File file = File.createTempFile("templates", ".zip");
+        Files.write(file.toPath(), zip);
+
+        try (ZipFile zipFile = new ZipFile(file)) {
+            assertThat(zipFile.stream().count(), is((long) size));
+        }
+
+        file.delete();
+    }
+
+    @Test
+    void extractByIds() throws IOException {
+        // create 3 templates, so we can retrieve them by id
+        var template1 = client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
+        var template2 = client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
+        var template3 = client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
+
+        List<String> ids = List.of(template1.getId(), template2.getId(), template3.getId());
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/templates/extract/by_ids?namespace=kestra.test", ids),
+            Argument.of(byte[].class));
+        File file = File.createTempFile("templates", ".zip");
+        Files.write(file.toPath(), zip);
+
+        try(ZipFile zipFile = new ZipFile(file)) {
+            assertThat(zipFile.stream().count(), is(3L));
+        }
+
+        file.delete();
+    }
 }

From abe57c3b237077bb75988f997f31d4d7073a555e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lo=C3=AFc=20Mathieu?= <loikeseke@gmail.com>
Date: Thu, 16 Feb 2023 10:10:49 +0100
Subject: [PATCH 2/9] fix: feedback from code review

---
 .../FlowNamespaceExtractCommand.java          |  2 +-
 .../TemplateNamespaceExtractCommand.java      |  2 +-
 .../core/models/templates/Template.java       | 16 ++------
 .../webserver/controllers/FlowController.java | 38 ++++++++-----------
 .../controllers/TemplateController.java       | 35 +++++++----------
 .../controllers/FlowControllerTest.java       |  4 +-
 .../controllers/TemplateControllerTest.java   |  4 +-
 7 files changed, 38 insertions(+), 63 deletions(-)

diff --git a/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java b/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java
index 37356ce3c5f..0c6f5b6984b 100644
--- a/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java
+++ b/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java
@@ -35,7 +35,7 @@ public Integer call() throws Exception {
 
         try(DefaultHttpClient client = client()) {
             MutableHttpRequest<Object> request = HttpRequest
-                .GET("/api/v1/flows/extract/by_query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
+                .GET("/api/v1/flows/extract/by-query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
 
             HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
             Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
diff --git a/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java b/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java
index 088b84b530a..c82f1415412 100644
--- a/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java
+++ b/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java
@@ -44,7 +44,7 @@ public Integer call() throws Exception {
 
         try(DefaultHttpClient client = client()) {
             MutableHttpRequest<Object> request = HttpRequest
-                .GET("/api/v1/templates/extract/by_query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
+                .GET("/api/v1/templates/extract/by-query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
 
             HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
             Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
diff --git a/core/src/main/java/io/kestra/core/models/templates/Template.java b/core/src/main/java/io/kestra/core/models/templates/Template.java
index 85f5e7c4c94..001f3566b71 100644
--- a/core/src/main/java/io/kestra/core/models/templates/Template.java
+++ b/core/src/main/java/io/kestra/core/models/templates/Template.java
@@ -32,14 +32,15 @@
 @EqualsAndHashCode
 public class Template implements DeletedInterface {
 
-    private static final ObjectMapper jsonMapper = JacksonMapper.ofJson().copy()
+    private static final ObjectMapper YAML_MAPPER = JacksonMapper.ofYaml().copy()
         .setAnnotationIntrospector(new JacksonAnnotationIntrospector() {
             @Override
             public boolean hasIgnoreMarker(final AnnotatedMember m) {
                 List<String> exclusions = Arrays.asList("revision", "deleted", "source");
                 return exclusions.contains(m.getName()) || super.hasIgnoreMarker(m);
             }
-        });
+        })
+        .setSerializationInclusion(JsonInclude.Include.NON_DEFAULT);
 
     @NotNull
     @NotBlank
@@ -111,16 +112,7 @@ public Optional<ConstraintViolationException> validateUpdate(Template updated) {
 
     public String generateSource() {
         try {
-            return JacksonMapper.ofYaml()
-                .writeValueAsString(
-                    JacksonMapper
-                        .ofJson()
-                        .readTree(
-                            jsonMapper.copy()
-                                .setSerializationInclusion(JsonInclude.Include.NON_DEFAULT)
-                                .writeValueAsString(this)
-                        )
-                );
+            return YAML_MAPPER.writeValueAsString(this);
         } catch (JsonProcessingException e) {
             throw new RuntimeException(e);
         }
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
index 26a09a199c1..310cc656c48 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
@@ -451,7 +451,7 @@ public List<ValidateConstraintViolation> validateFlows(
     }
 
     @ExecuteOn(TaskExecutors.IO)
-    @Get(uri = "/extract/by_query", produces = MediaType.APPLICATION_OCTET_STREAM)
+    @Get(uri = "/extract/by-query", produces = MediaType.APPLICATION_OCTET_STREAM)
     @Operation(
         tags = {"Flows"},
         summary = "Extract flows as a ZIP archive of yaml sources."
@@ -461,25 +461,13 @@ public HttpResponse<byte[]> extractByQuery(
         @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue(value = "namespace") String namespace,
         @Parameter(description = "A labels filter") @Nullable @QueryValue List<String> labels
     ) throws IOException {
-        try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
-            ZipOutputStream archive = new ZipOutputStream(bos)) {
-
-            List<FlowWithSource> toExtract = flowRepository.findWithSource(query, namespace, RequestUtils.toMap(labels));
-            for(var flowWithSource : toExtract) {
-                var zipEntry = new ZipEntry(flowWithSource.getNamespace() + "-" + flowWithSource.getId() + ".yml");
-                archive.putNextEntry(zipEntry);
-                archive.write(flowWithSource.getSource().getBytes());
-                archive.closeEntry();
-            }
-
-            archive.finish();
-            return HttpResponse.ok(bos.toByteArray())
-                .header("Content-Disposition", "attachment; filename=\"flows.zip\"");
-        }
+        var flows = flowRepository.findWithSource(query, namespace, RequestUtils.toMap(labels));
+        var bytes = zipFlows(flows);
+        return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"flows.zip\"");
     }
 
     @ExecuteOn(TaskExecutors.IO)
-    @Post(uri = "/extract/by_ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
+    @Post(uri = "/extract/by-ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
     @Operation(
         tags = {"Flows"},
         summary = "Extract flows as a ZIP archive of yaml sources."
@@ -488,20 +476,24 @@ public HttpResponse<byte[]> extractByIds(
         @Parameter(description = "A namespace filter prefix") @QueryValue(value = "namespace") String namespace,
         @Parameter(description = "A list of string identifiers") @Body List<String> ids
     ) throws IOException {
+        var flows = ids.stream().map(id -> flowRepository.findByIdWithSource(namespace, id).orElseThrow()).collect(Collectors.toList());
+        var bytes = zipFlows(flows);
+        return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"flows.zip\"");
+    }
+
+    private byte[] zipFlows(List<FlowWithSource> flows) throws IOException {
         try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ZipOutputStream archive = new ZipOutputStream(bos)) {
 
-            for(var id : ids) {
-                FlowWithSource flowWithSource = flowRepository.findByIdWithSource(namespace, id).orElseThrow();
-                var zipEntry = new ZipEntry(flowWithSource.getNamespace() + "-" + flowWithSource.getId() + ".yml");
+            for(var flow : flows) {
+                var zipEntry = new ZipEntry(flow.getNamespace() + "-" + flow.getId() + ".yml");
                 archive.putNextEntry(zipEntry);
-                archive.write(flowWithSource.getSource().getBytes());
+                archive.write(flow.getSource().getBytes());
                 archive.closeEntry();
             }
 
             archive.finish();
-            return HttpResponse.ok(bos.toByteArray())
-                .header("Content-Disposition", "attachment; filename=\"flows.zip\"");
+            return bos.toByteArray();
         }
     }
 }
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
index a4983049f5d..7d7e8c26ac4 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
@@ -250,7 +250,7 @@ public List<ValidateConstraintViolation> validateTemplates(
     }
 
     @ExecuteOn(TaskExecutors.IO)
-    @Get(uri = "/extract/by_query", produces = MediaType.APPLICATION_OCTET_STREAM)
+    @Get(uri = "/extract/by-query", produces = MediaType.APPLICATION_OCTET_STREAM)
     @Operation(
         summary = "Extract templates as a ZIP archive of yaml sources."
     )
@@ -258,26 +258,13 @@ public HttpResponse<byte[]> extractByQuery(
         @Parameter(description = "A string filter") @Nullable @QueryValue(value = "q") String query,
         @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue(value = "namespace") String namespace
     ) throws IOException {
-        try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
-            ZipOutputStream archive = new ZipOutputStream(bos)) {
-
-            List<Template> toExtract = templateRepository.find(query, namespace);
-            System.out.println(toExtract.size());
-            for(var template : toExtract) {
-                var zipEntry = new ZipEntry(template.getNamespace() + "-" + template.getId() + ".yml");
-                archive.putNextEntry(zipEntry);
-                archive.write(template.generateSource().getBytes());
-                archive.closeEntry();
-            }
-
-            archive.finish();
-            return HttpResponse.ok(bos.toByteArray())
-                .header("Content-Disposition", "attachment; filename=\"templates.zip\"");
-        }
+        var templates = templateRepository.find(query, namespace);
+        var bytes = zipTemplates(templates);
+        return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"templates.zip\"");
     }
 
     @ExecuteOn(TaskExecutors.IO)
-    @Post(uri = "/extract/by_ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
+    @Post(uri = "/extract/by-ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
     @Operation(
         summary = "Extract templates as a ZIP archive of yaml sources."
     )
@@ -285,11 +272,16 @@ public HttpResponse<byte[]> extractByIds(
         @Parameter(description = "A namespace filter prefix") @QueryValue(value = "namespace") String namespace,
         @Parameter(description = "A list of string identifiers") @Body List<String> ids
     ) throws IOException {
+        var templates = ids.stream().map(id -> templateRepository.findById(namespace, id).orElseThrow()).collect(Collectors.toList());
+        var bytes = zipTemplates(templates);
+        return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"templates.zip\"");
+    }
+
+    private byte[] zipTemplates(List<Template> templates) throws IOException {
         try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ZipOutputStream archive = new ZipOutputStream(bos)) {
 
-            for(var id : ids) {
-                var template = templateRepository.findById(namespace, id).orElseThrow();
+            for(var template : templates) {
                 var zipEntry = new ZipEntry(template.getNamespace() + "-" + template.getId() + ".yml");
                 archive.putNextEntry(zipEntry);
                 archive.write(template.generateSource().getBytes());
@@ -297,8 +289,7 @@ public HttpResponse<byte[]> extractByIds(
             }
 
             archive.finish();
-            return HttpResponse.ok(bos.toByteArray())
-                .header("Content-Disposition", "attachment; filename=\"templates.zip\"");
+            return bos.toByteArray();
         }
     }
 }
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
index ff0cd9c9a4f..ee34ddf068c 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
@@ -457,7 +457,7 @@ void updateInvalidFlowFromString() throws IOException {
 
     @Test
     void extractByQuery() throws IOException {
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/flows/extract/by_query?namespace=io.kestra.tests"),
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/flows/extract/by-query?namespace=io.kestra.tests"),
             Argument.of(byte[].class));
         File file = File.createTempFile("flows", ".zip");
         Files.write(file.toPath(), zip);
@@ -472,7 +472,7 @@ void extractByQuery() throws IOException {
     @Test
     void extractByIds() throws IOException {
         List<String> ids = List.of("each-object", "webhook", "task-flow");
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/flows/extract/by_ids?namespace=io.kestra.tests", ids),
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/flows/extract/by-ids?namespace=io.kestra.tests", ids),
             Argument.of(byte[].class));
         File file = File.createTempFile("flows", ".zip");
         Files.write(file.toPath(), zip);
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
index 0360820d7b4..a074e923b2d 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
@@ -135,7 +135,7 @@ void extractByQuery() throws IOException {
         client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
         int size = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/templates/search?namespace=kestra.test"), Argument.of(PagedResults.class, Template.class)).getResults().size();
 
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/templates/extract/by_query?namespace=kestra.test"),
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/templates/extract/by-query?namespace=kestra.test"),
             Argument.of(byte[].class));
         File file = File.createTempFile("templates", ".zip");
         Files.write(file.toPath(), zip);
@@ -155,7 +155,7 @@ void extractByIds() throws IOException {
         var template3 = client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
 
         List<String> ids = List.of(template1.getId(), template2.getId(), template3.getId());
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/templates/extract/by_ids?namespace=kestra.test", ids),
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/templates/extract/by-ids?namespace=kestra.test", ids),
             Argument.of(byte[].class));
         File file = File.createTempFile("templates", ".zip");
         Files.write(file.toPath(), zip);

From 5e470b9e5068d5376c3fc5dbf16a05528d4c5e7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lo=C3=AFc=20Mathieu?= <loikeseke@gmail.com>
Date: Fri, 17 Feb 2023 09:59:49 +0100
Subject: [PATCH 3/9] fix(webserver): extract by-ids based on a lit of
 IdWithNamespace

So that we can extract flows and templates from different namespace in one call.
---
 .../kestra/webserver/controllers/FlowController.java | 10 ++++++----
 .../webserver/controllers/StatsController.java       |  1 -
 .../webserver/controllers/TemplateController.java    | 10 ++++++----
 .../controllers/domain/IdWithNamespace.java          | 12 ++++++++++++
 .../webserver/controllers/FlowControllerTest.java    |  8 ++++++--
 .../controllers/TemplateControllerTest.java          |  6 +++++-
 6 files changed, 35 insertions(+), 12 deletions(-)
 create mode 100644 webserver/src/main/java/io/kestra/webserver/controllers/domain/IdWithNamespace.java

diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
index 310cc656c48..8c406e2143a 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
@@ -17,6 +17,7 @@
 import io.kestra.core.serializers.YamlFlowParser;
 import io.kestra.core.services.TaskDefaultService;
 import io.kestra.core.topologies.FlowTopologyService;
+import io.kestra.webserver.controllers.domain.IdWithNamespace;
 import io.kestra.webserver.responses.PagedResults;
 import io.kestra.webserver.utils.PageableUtils;
 import io.kestra.webserver.utils.RequestUtils;
@@ -473,10 +474,11 @@ public HttpResponse<byte[]> extractByQuery(
         summary = "Extract flows as a ZIP archive of yaml sources."
     )
     public HttpResponse<byte[]> extractByIds(
-        @Parameter(description = "A namespace filter prefix") @QueryValue(value = "namespace") String namespace,
-        @Parameter(description = "A list of string identifiers") @Body List<String> ids
+        @Parameter(description = "A list of tuple flow ID and namespace as flow identifiers") @Body List<IdWithNamespace> ids
     ) throws IOException {
-        var flows = ids.stream().map(id -> flowRepository.findByIdWithSource(namespace, id).orElseThrow()).collect(Collectors.toList());
+        var flows = ids.stream()
+            .map(id -> flowRepository.findByIdWithSource(id.getNamespace(), id.getId()).orElseThrow())
+            .collect(Collectors.toList());
         var bytes = zipFlows(flows);
         return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"flows.zip\"");
     }
@@ -486,7 +488,7 @@ private byte[] zipFlows(List<FlowWithSource> flows) throws IOException {
             ZipOutputStream archive = new ZipOutputStream(bos)) {
 
             for(var flow : flows) {
-                var zipEntry = new ZipEntry(flow.getNamespace() + "-" + flow.getId() + ".yml");
+                var zipEntry = new ZipEntry(flow.getNamespace() + "." + flow.getId() + ".yml");
                 archive.putNextEntry(zipEntry);
                 archive.write(flow.getSource().getBytes());
                 archive.closeEntry();
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/StatsController.java b/webserver/src/main/java/io/kestra/webserver/controllers/StatsController.java
index b21693ec295..651e9156408 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/StatsController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/StatsController.java
@@ -4,7 +4,6 @@
 import io.micronaut.http.MediaType;
 import io.micronaut.http.annotation.Controller;
 import io.micronaut.http.annotation.Post;
-import io.micronaut.http.annotation.QueryValue;
 import io.micronaut.scheduling.TaskExecutors;
 import io.micronaut.scheduling.annotation.ExecuteOn;
 import io.micronaut.validation.Validated;
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
index 7d7e8c26ac4..e480f842ee3 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
@@ -6,6 +6,7 @@
 import io.kestra.core.models.validations.ValidateConstraintViolation;
 import io.kestra.core.repositories.TemplateRepositoryInterface;
 import io.kestra.core.serializers.YamlFlowParser;
+import io.kestra.webserver.controllers.domain.IdWithNamespace;
 import io.kestra.webserver.responses.PagedResults;
 import io.kestra.webserver.utils.PageableUtils;
 import io.micronaut.core.annotation.Nullable;
@@ -269,10 +270,11 @@ public HttpResponse<byte[]> extractByQuery(
         summary = "Extract templates as a ZIP archive of yaml sources."
     )
     public HttpResponse<byte[]> extractByIds(
-        @Parameter(description = "A namespace filter prefix") @QueryValue(value = "namespace") String namespace,
-        @Parameter(description = "A list of string identifiers") @Body List<String> ids
+        @Parameter(description = "A list of tuple flow ID and namespace as template identifiers") @Body List<IdWithNamespace> ids
     ) throws IOException {
-        var templates = ids.stream().map(id -> templateRepository.findById(namespace, id).orElseThrow()).collect(Collectors.toList());
+        var templates = ids.stream()
+            .map(id -> templateRepository.findById(id.getNamespace(), id.getId()).orElseThrow())
+            .collect(Collectors.toList());
         var bytes = zipTemplates(templates);
         return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"templates.zip\"");
     }
@@ -282,7 +284,7 @@ private byte[] zipTemplates(List<Template> templates) throws IOException {
             ZipOutputStream archive = new ZipOutputStream(bos)) {
 
             for(var template : templates) {
-                var zipEntry = new ZipEntry(template.getNamespace() + "-" + template.getId() + ".yml");
+                var zipEntry = new ZipEntry(template.getNamespace() + "." + template.getId() + ".yml");
                 archive.putNextEntry(zipEntry);
                 archive.write(template.generateSource().getBytes());
                 archive.closeEntry();
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/domain/IdWithNamespace.java b/webserver/src/main/java/io/kestra/webserver/controllers/domain/IdWithNamespace.java
new file mode 100644
index 00000000000..dc7b5050f81
--- /dev/null
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/domain/IdWithNamespace.java
@@ -0,0 +1,12 @@
+package io.kestra.webserver.controllers.domain;
+
+import lombok.*;
+
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class IdWithNamespace {
+    private String namespace;
+    private String id;
+}
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
index ee34ddf068c..6114bc1d15d 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
@@ -6,6 +6,7 @@
 import io.kestra.core.serializers.YamlFlowParser;
 import io.kestra.core.tasks.flows.Sequential;
 import io.kestra.core.utils.TestsUtils;
+import io.kestra.webserver.controllers.domain.IdWithNamespace;
 import io.micronaut.core.type.Argument;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.HttpResponse;
@@ -471,8 +472,11 @@ void extractByQuery() throws IOException {
 
     @Test
     void extractByIds() throws IOException {
-        List<String> ids = List.of("each-object", "webhook", "task-flow");
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/flows/extract/by-ids?namespace=io.kestra.tests", ids),
+        List<IdWithNamespace> ids = List.of(
+            new IdWithNamespace("io.kestra.tests", "each-object"),
+            new IdWithNamespace("io.kestra.tests", "webhook"),
+            new IdWithNamespace("io.kestra.tests", "task-flow"));
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/flows/extract/by-ids", ids),
             Argument.of(byte[].class));
         File file = File.createTempFile("flows", ".zip");
         Files.write(file.toPath(), zip);
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
index a074e923b2d..423da09849b 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
@@ -1,5 +1,6 @@
 package io.kestra.webserver.controllers;
 
+import io.kestra.webserver.controllers.domain.IdWithNamespace;
 import io.micronaut.core.type.Argument;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.HttpResponse;
@@ -154,7 +155,10 @@ void extractByIds() throws IOException {
         var template2 = client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
         var template3 = client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
 
-        List<String> ids = List.of(template1.getId(), template2.getId(), template3.getId());
+        List<IdWithNamespace> ids = List.of(
+            new IdWithNamespace("kestra.test", template1.getId()),
+            new IdWithNamespace("kestra.test", template2.getId()),
+            new IdWithNamespace("kestra.test", template3.getId()));
         byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/templates/extract/by-ids?namespace=kestra.test", ids),
             Argument.of(byte[].class));
         File file = File.createTempFile("templates", ".zip");

From 81c737dee4d513cb9964a66064ada89188ef60f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lo=C3=AFc=20Mathieu?= <loikeseke@gmail.com>
Date: Fri, 17 Feb 2023 10:02:50 +0100
Subject: [PATCH 4/9] chore(webserver): @ApiResponses is not needed as
 @ApiResponse is repeatable

---
 .../controllers/ExecutionController.java      | 37 +++++--------------
 .../webserver/controllers/FlowController.java |  5 +--
 .../controllers/TemplateController.java       |  5 +--
 3 files changed, 11 insertions(+), 36 deletions(-)

diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/ExecutionController.java b/webserver/src/main/java/io/kestra/webserver/controllers/ExecutionController.java
index f159c3944f7..1f17d70796e 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/ExecutionController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/ExecutionController.java
@@ -26,7 +26,6 @@
 import io.swagger.v3.oas.annotations.media.Content;
 import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
-import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import lombok.*;
 import lombok.experimental.SuperBuilder;
 import org.apache.commons.io.FilenameUtils;
@@ -261,9 +260,7 @@ public Execution get(
     @Delete(uri = "executions/{executionId}", produces = MediaType.TEXT_JSON)
     @ExecuteOn(TaskExecutors.IO)
     @Operation(tags = {"Executions"}, summary = "Delete an execution")
-    @ApiResponses(
-        @ApiResponse(responseCode = "204", description = "On success")
-    )
+    @ApiResponse(responseCode = "204", description = "On success")
     public HttpResponse<Void> delete(
         @Parameter(description = "The execution id") String executionId
     ) {
@@ -279,12 +276,8 @@ public HttpResponse<Void> delete(
     @Delete(uri = "executions/by-ids", produces = MediaType.TEXT_JSON)
     @ExecuteOn(TaskExecutors.IO)
     @Operation(tags = {"Executions"}, summary = "Delete a list of executions")
-    @ApiResponses(
-        value = {
-            @ApiResponse(responseCode = "200", content = {@Content(schema = @Schema(implementation = BulkResponse.class))}),
-            @ApiResponse(responseCode = "422", content = {@Content(schema = @Schema(implementation = BulkErrorResponse.class))})
-        }
-    )
+    @ApiResponse(responseCode = "200", content = {@Content(schema = @Schema(implementation = BulkResponse.class))})
+    @ApiResponse(responseCode = "422", content = {@Content(schema = @Schema(implementation = BulkErrorResponse.class))})
     public MutableHttpResponse<?> deleteByIds(
         @Parameter(description = "The execution id") @Body List<String> executionsId
     ) {
@@ -599,12 +592,8 @@ public Execution restart(
     @ExecuteOn(TaskExecutors.IO)
     @Post(uri = "executions/restart/by-ids", produces = MediaType.TEXT_JSON)
     @Operation(tags = {"Executions"}, summary = "Restart a list of executions")
-    @ApiResponses(
-        value = {
-            @ApiResponse(responseCode = "200", content = {@Content(schema = @Schema(implementation = BulkResponse.class))}),
-            @ApiResponse(responseCode = "422", content = {@Content(schema = @Schema(implementation = BulkErrorResponse.class))})
-        }
-    )
+    @ApiResponse(responseCode = "200", content = {@Content(schema = @Schema(implementation = BulkResponse.class))})
+    @ApiResponse(responseCode = "422", content = {@Content(schema = @Schema(implementation = BulkErrorResponse.class))})
     public MutableHttpResponse<?> restartByIds(
         @Parameter(description = "The execution id") @Body List<String> executionsId
     ) throws Exception {
@@ -749,12 +738,8 @@ public static class StateRequest {
     @ExecuteOn(TaskExecutors.IO)
     @Delete(uri = "executions/{executionId}/kill", produces = MediaType.TEXT_JSON)
     @Operation(tags = {"Executions"}, summary = "Kill an execution")
-    @ApiResponses(
-        value = {
-            @ApiResponse(responseCode = "204", description = "On success"),
-            @ApiResponse(responseCode = "409", description = "if the executions is already finished")
-        }
-    )
+    @ApiResponse(responseCode = "204", description = "On success")
+    @ApiResponse(responseCode = "409", description = "if the executions is already finished")
     public HttpResponse<?> kill(
         @Parameter(description = "The execution id") String executionId
     ) {
@@ -775,12 +760,8 @@ public HttpResponse<?> kill(
     @ExecuteOn(TaskExecutors.IO)
     @Delete(uri = "executions/kill/by-ids", produces = MediaType.TEXT_JSON)
     @Operation(tags = {"Executions"}, summary = "Kill a list of executions")
-    @ApiResponses(
-        value = {
-            @ApiResponse(responseCode = "200", content = {@Content(schema = @Schema(implementation = BulkResponse.class))}),
-            @ApiResponse(responseCode = "422", content = {@Content(schema = @Schema(implementation = BulkErrorResponse.class))})
-        }
-    )
+    @ApiResponse(responseCode = "200", content = {@Content(schema = @Schema(implementation = BulkResponse.class))})
+    @ApiResponse(responseCode = "422", content = {@Content(schema = @Schema(implementation = BulkErrorResponse.class))})
     public MutableHttpResponse<?> killByIds(
         @Parameter(description = "The execution id") @Body List<String> executionsId
     ) {
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
index 8c406e2143a..904aff99aa2 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
@@ -34,7 +34,6 @@
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
-import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import jakarta.inject.Inject;
 
 import java.io.ByteArrayOutputStream;
@@ -381,9 +380,7 @@ public HttpResponse<Flow> updateTask(
     @Delete(uri = "{namespace}/{id}", produces = MediaType.TEXT_JSON)
     @ExecuteOn(TaskExecutors.IO)
     @Operation(tags = {"Flows"}, summary = "Delete a flow")
-    @ApiResponses(
-        @ApiResponse(responseCode = "204", description = "On success")
-    )
+    @ApiResponse(responseCode = "204", description = "On success")
     public HttpResponse<Void> delete(
         @Parameter(description = "The flow namespace") String namespace,
         @Parameter(description = "The flow id") String id
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
index e480f842ee3..858312d70f1 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
@@ -21,7 +21,6 @@
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
-import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import jakarta.inject.Inject;
 
 import java.io.ByteArrayOutputStream;
@@ -108,9 +107,7 @@ public HttpResponse<Template> update(
     @ExecuteOn(TaskExecutors.IO)
     @Delete(uri = "{namespace}/{id}", produces = MediaType.TEXT_JSON)
     @Operation(tags = {"Template"}, summary = "Delete a template")
-    @ApiResponses(
-        @ApiResponse(responseCode = "204", description = "On success")
-    )
+    @ApiResponse(responseCode = "204", description = "On success")
     public HttpResponse<Void> delete(
         @Parameter(description = "The template namespace") String namespace,
         @Parameter(description = "The template id") String id

From 48ff49d75b286cf1f35c7dfbac48cca74a429c87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lo=C3=AFc=20Mathieu?= <loikeseke@gmail.com>
Date: Fri, 17 Feb 2023 11:57:43 +0100
Subject: [PATCH 5/9] fix(webserver): remove un-needed annotation value

---
 .../java/io/kestra/webserver/controllers/FlowController.java    | 2 +-
 .../io/kestra/webserver/controllers/TemplateController.java     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
index 904aff99aa2..2eb092f0474 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
@@ -456,7 +456,7 @@ public List<ValidateConstraintViolation> validateFlows(
     )
     public HttpResponse<byte[]> extractByQuery(
         @Parameter(description = "A string filter") @Nullable @QueryValue(value = "q") String query,
-        @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue(value = "namespace") String namespace,
+        @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue String namespace,
         @Parameter(description = "A labels filter") @Nullable @QueryValue List<String> labels
     ) throws IOException {
         var flows = flowRepository.findWithSource(query, namespace, RequestUtils.toMap(labels));
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
index 858312d70f1..4d64951402a 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
@@ -254,7 +254,7 @@ public List<ValidateConstraintViolation> validateTemplates(
     )
     public HttpResponse<byte[]> extractByQuery(
         @Parameter(description = "A string filter") @Nullable @QueryValue(value = "q") String query,
-        @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue(value = "namespace") String namespace
+        @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue String namespace
     ) throws IOException {
         var templates = templateRepository.find(query, namespace);
         var bytes = zipTemplates(templates);

From 0f08b12664f0c72a8cd35320fc86ca97a4d747fe Mon Sep 17 00:00:00 2001
From: Yann C <yann.coornaert62@orange.fr>
Date: Thu, 16 Feb 2023 18:00:51 +0100
Subject: [PATCH 6/9] feat(ui): Implement extract flows endpoints

---
 ui/src/components/flows/Flows.vue         | 59 ++++++++++++++++++++++-
 ui/src/components/templates/Templates.vue | 58 ++++++++++++++++++++++
 ui/src/stores/flow.js                     | 48 +++++++++++-------
 ui/src/stores/template.js                 | 15 ++++++
 ui/src/translations.json                  | 20 ++++++--
 ui/src/utils/utils.js                     |  8 +++
 6 files changed, 186 insertions(+), 22 deletions(-)

diff --git a/ui/src/components/flows/Flows.vue b/ui/src/components/flows/Flows.vue
index 96a2535739a..cc50b70d55d 100644
--- a/ui/src/components/flows/Flows.vue
+++ b/ui/src/components/flows/Flows.vue
@@ -39,7 +39,9 @@
                         @row-dblclick="onRowDoubleClick"
                         @sort-change="onSort"
                         :row-class-name="rowClasses"
+                        @selection-change="handleSelectionChange"
                     >
+                        <el-table-column type="selection" v-if="(canRead)" />
                         <el-table-column prop="id" sortable="custom" :sort-orders="['ascending', 'descending']" :label="$t('id')">
                             <template #default="scope">
                                 <router-link
@@ -102,6 +104,15 @@
 
         <bottom-line>
             <ul>
+                <ul v-if="flowsSelection.length !== 0 && canRead">
+                    <bottom-line-counter v-model="queryBulkAction" :selections="flowsSelection" :total="total" @update:model-value="selectAll()" />
+                    <li v-if="canRead">
+                        <el-button :icon="Download" type="info" class="bulk-button" @click="exportFlows()">
+                            {{ $t('exports') }}
+                        </el-button>
+                    </li>
+                </ul>
+                <li class="spacer" />
                 <li>
                     <router-link :to="{name: 'flows/search'}">
                         <el-button :icon="TextBoxSearch">
@@ -125,6 +136,7 @@
 <script setup>
     import Plus from "vue-material-design-icons/Plus.vue";
     import TextBoxSearch from "vue-material-design-icons/TextBoxSearch.vue";
+    import Download from "vue-material-design-icons/Download.vue";
 </script>
 
 <script>
@@ -146,6 +158,7 @@
     import MarkdownTooltip from "../layout/MarkdownTooltip.vue"
     import Kicon from "../Kicon.vue"
     import Labels from "../layout/Labels.vue"
+    import BottomLineCounter from "../layout/BottomLineCounter.vue";
 
     export default {
         mixins: [RouteContext, RestoreUrl, DataTableActions],
@@ -161,6 +174,7 @@
             MarkdownTooltip,
             Kicon,
             Labels,
+            BottomLineCounter,
         },
         data() {
             return {
@@ -169,6 +183,8 @@
                 action: action,
                 dailyGroupByFlowReady: false,
                 dailyReady: false,
+                flowsSelection: [],
+                queryBulkAction: false
             };
         },
         computed: {
@@ -187,9 +203,50 @@
                 return this.$moment(this.endDate)
                     .add(-30, "days")
                     .toDate();
-            }
+            },
+            canRead() {
+                return this.user && this.user.isAllowed(permission.FLOW, action.READ);
+            },
         },
         methods: {
+            handleSelectionChange(val) {
+                if (val.length === 0) {
+                    this.queryBulkAction = false
+                }
+                this.flowsSelection = val.map(x => {
+                    return {
+                        id: x.id,
+                        namespace: x.namespace
+                    }
+                });
+            },
+            selectAll() {
+                this.$refs.table.toggleAllSelection();
+            },
+            exportFlows() {
+                this.$toast().confirm(
+                    this.$t("flow export", {"flowCount": this.queryBulkAction ? this.total : this.flowsSelection.length}),
+                    () => {
+                        if (this.queryBulkAction) {
+                            return this.$store
+                                .dispatch("flow/exportFlowByQuery", this.loadQuery({
+                                    namespace: this.$route.query.namespace ? [this.$route.query.namespace] : "",
+                                    q: this.$route.query.q ? [this.$route.query.q] : "",
+                                }, false))
+                                .then(_ => {
+                                    this.$toast().success(this.$t("flows exported"));
+                                })
+                        } else {
+                            return this.$store
+                                .dispatch("flow/exportFlowByIds", {ids: this.flowsSelection})
+                                .then(_ => {
+                                    this.$toast().success(this.$t("flows exported"));
+                                })
+                        }
+                    },
+                    () => {}
+                )
+            },
             chartData(row) {
                 if (this.dailyGroupByFlow && this.dailyGroupByFlow[row.namespace] && this.dailyGroupByFlow[row.namespace][row.id]) {
                     return this.dailyGroupByFlow[row.namespace][row.id];
diff --git a/ui/src/components/templates/Templates.vue b/ui/src/components/templates/Templates.vue
index 5b23eeefac8..6fdd997a614 100644
--- a/ui/src/components/templates/Templates.vue
+++ b/ui/src/components/templates/Templates.vue
@@ -29,7 +29,9 @@
                         fixed
                         @row-dblclick="onRowDoubleClick"
                         @sort-change="onSort"
+                        @selection-change="handleSelectionChange"
                     >
+                        <el-table-column type="selection" v-if="(canRead)" />
                         <el-table-column prop="id" sortable="custom" :sort-orders="['ascending', 'descending']" :label="$t('id')">
                             <template #default="scope">
                                 <router-link
@@ -62,6 +64,16 @@
 
         <bottom-line v-if="user && user.hasAnyAction(permission.TEMPLATE, action.CREATE)">
             <ul>
+                <ul v-if="templatesSelection.length !== 0 && canRead">
+                    <bottom-line-counter v-model="queryBulkAction" :selections="templatesSelection" :total="total" @update:model-value="selectAll()" />
+                    <li v-if="canRead">
+                        <el-button :icon="Download" type="info" class="bulk-button" @click="exportTemplates()">
+                            {{ $t('exports') }}
+                        </el-button>
+                    </li>
+                </ul>
+
+                <li class="spacer" />
                 <li>
                     <router-link :to="{name: 'templates/create'}">
                         <el-button :icon="Plus" type="primary">
@@ -76,6 +88,7 @@
 
 <script setup>
     import Plus from "vue-material-design-icons/Plus.vue";
+    import Download from "vue-material-design-icons/Download.vue";
 </script>
 
 <script>
@@ -93,6 +106,7 @@
     import RestoreUrl from "../../mixins/restoreUrl";
     import _merge from "lodash/merge";
     import MarkdownTooltip from "../../components/layout/MarkdownTooltip.vue";
+    import BottomLineCounter from "../layout/BottomLineCounter.vue";
 
     export default {
         mixins: [RouteContext, RestoreUrl, DataTableActions],
@@ -104,12 +118,15 @@
             NamespaceSelect,
             Kicon,
             MarkdownTooltip,
+            BottomLineCounter,
         },
         data() {
             return {
                 isDefaultNamespaceAllow: true,
                 permission: permission,
                 action: action,
+                templatesSelection: [],
+                queryBulkAction: false
             };
         },
         computed: {
@@ -121,6 +138,9 @@
                     title: this.$t("templates")
                 };
             },
+            canRead() {
+                return this.user && this.user.isAllowed(permission.FLOW, action.READ);
+            },
         },
         methods: {
             loadQuery(base) {
@@ -139,6 +159,44 @@
                         callback();
                     });
             },
+            handleSelectionChange(val) {
+                if (val.length === 0) {
+                    this.queryBulkAction = false
+                }
+                this.templatesSelection = val.map(x => {
+                    return {
+                        id: x.id,
+                        namespace: x.namespace
+                    }
+                });
+            },
+            selectAll() {
+                this.$refs.table.toggleAllSelection();
+            },
+            exportTemplates() {
+                this.$toast().confirm(
+                    this.$t("template export", {"templateCount": this.queryBulkAction ? this.total : this.templatesSelection.length}),
+                    () => {
+                        if (this.queryBulkAction) {
+                            return this.$store
+                                .dispatch("template/exportTemplateByQuery", this.loadQuery({
+                                    namespace: this.$route.query.namespace ? [this.$route.query.namespace] : "",
+                                    q: this.$route.query.q ? [this.$route.query.q] : "",
+                                }, false))
+                                .then(_ => {
+                                    this.$toast().success(this.$t("templates exported"));
+                                })
+                        } else {
+                            return this.$store
+                                .dispatch("template/exportTemplateByIds", {ids: this.templatesSelection})
+                                .then(_ => {
+                                    this.$toast().success(this.$t("templates exported"));
+                                })
+                        }
+                    },
+                    () => {}
+                )
+            },
         },
     };
 </script>
diff --git a/ui/src/stores/flow.js b/ui/src/stores/flow.js
index 8c172a26b88..0117c2782de 100644
--- a/ui/src/stores/flow.js
+++ b/ui/src/stores/flow.js
@@ -1,4 +1,5 @@
 import YamlUtils from "../utils/yamlUtils";
+import Utils from "../utils/utils";
 
 const textYamlHeader = {
     headers: {
@@ -50,20 +51,20 @@ export default {
                         return options.deleted ? status === 200 || status === 404 : status === 200;
                     }
                 }).then(response => {
-                    if (response.data.exception) {
-                        commit("core/setMessage", {
-                            title: "Invalid source code",
-                            message: response.data.exception,
-                            variant: "danger"
-                        }, {root: true});
-                        delete response.data.exception;
-                        commit("setFlow", JSON.parse(response.data.source));
-                    } else {
-                        commit("setFlow", response.data);
-                    }
+                if (response.data.exception) {
+                    commit("core/setMessage", {
+                        title: "Invalid source code",
+                        message: response.data.exception,
+                        variant: "danger"
+                    }, {root: true});
+                    delete response.data.exception;
+                    commit("setFlow", JSON.parse(response.data.source));
+                } else {
+                    commit("setFlow", response.data);
+                }
 
-                    return response.data;
-                })
+                return response.data;
+            })
         },
         loadTask({commit}, options) {
             return this.$http.get(`/api/v1/flows/${options.namespace}/${options.id}/tasks/${options.taskId}${options.revision ? "?revision=" + options.revision : ""}`).then(response => {
@@ -131,10 +132,23 @@ export default {
         loadRevisions({commit}, options) {
             return this.$http.get(`/api/v1/flows/${options.namespace}/${options.id}/revisions`).then(response => {
                 commit("setRevisions", response.data)
-
                 return response.data;
             })
         },
+        exportFlowByIds(_, options) {
+            return this.$http.post("/api/v1/flows/extract/by-ids", options.ids, {responseType: "blob"})
+                .then(response => {
+                    const blob = new Blob([response.data], {type: "application/octet-stream"});
+                    const url = window.URL.createObjectURL(blob)
+                    Utils.downloadUrl(url, "flows.zip");
+                });
+        },
+        exportFlowByQuery(_, options) {
+            return this.$http.get("/api/v1/flows/extract/by-query", {params: options})
+                .then(response => {
+                    Utils.downloadUrl(response.request.responseURL, "flows.zip");
+                });
+        },
     },
     mutations: {
         setFlows(state, flows) {
@@ -181,7 +195,7 @@ export default {
         addTrigger(state, trigger) {
             let flow = state.flow;
 
-            if (trigger.backfill  === undefined) {
+            if (trigger.backfill === undefined) {
                 trigger.backfill = {
                     start: undefined
                 }
@@ -200,10 +214,10 @@ export default {
         },
         setFlowGraph(state, flowGraph) {
             state.flowGraph = flowGraph
-        }
+        },
     },
     getters: {
-        flow (state) {
+        flow(state) {
             if (state.flow) {
                 return state.flow;
             }
diff --git a/ui/src/stores/template.js b/ui/src/stores/template.js
index e529cac8d07..314baeee4c0 100644
--- a/ui/src/stores/template.js
+++ b/ui/src/stores/template.js
@@ -1,4 +1,5 @@
 import YamlUtils from "../utils/yamlUtils";
+import Utils from "../utils/utils";
 
 export default {
     namespaced: true,
@@ -58,6 +59,20 @@ export default {
                 commit("setTemplate", null)
             })
         },
+        exportTemplateByIds(_, options) {
+            return this.$http.post("/api/v1/templates/extract/by-ids", options.ids, {responseType: "blob"})
+                .then(response => {
+                    const blob = new Blob([response.data], {type: "application/octet-stream"});
+                    const url = window.URL.createObjectURL(blob)
+                    Utils.downloadUrl(url, "templates.zip");
+                });
+        },
+        exportTemplateByQuery(_, options) {
+            return this.$http.get("/api/v1/templates/extract/by-query", {params: options})
+                .then(response => {
+                    Utils.downloadUrl(response.request.responseURL, "templates.zip");
+                });
+        },
     },
     mutations: {
         setTemplates(state, templates) {
diff --git a/ui/src/translations.json b/ui/src/translations.json
index 96ed155b2a8..e987e7ba5c1 100644
--- a/ui/src/translations.json
+++ b/ui/src/translations.json
@@ -270,7 +270,11 @@
     "execution not found": "Execution <code>{executionId}</code> not found",
     "execution not in state FAILED": "Execution <code>{executionId}</code> not in state FAILED",
     "execution already finished": "Execution <code>{executionId}</code> already finished",
-    "seeing old revision": "You are seeing an old revision: {revision}"
+    "seeing old revision": "You are seeing an old revision: {revision}",
+    "template export": "Are you sure you want to export <code>{templateCount}</code> template(s)?",
+    "templates exported": "Templates exported",
+    "flow export": "Are you sure you want to export <code>{flowCount}</code> flow(s)?",
+    "flows exported": "Flows exported"
   },
   "fr": {
     "id": "Identifiant",
@@ -291,7 +295,7 @@
     "Default page": "Page par défaut",
     "confirmation": "Confirmation",
     "delete confirm": "Êtes-vous sur de vouloir effacer <code>{name}</code> ?",
-    "success": "Succcès",
+    "success": "Succès",
     "save": "Enregistrer",
     "saved": "Enregistrement réussi",
     "saved done": "<em>{name}</em> est enregistré avec succès",
@@ -544,7 +548,11 @@
     "execution not in state FAILED": "Execution <code>{executionId}</code> n'est pas dans l'état FAILED",
     "execution already finished": "Execution <code>{executionId}</code> déjà terminée",
     "restore revision": "Êtes-vous sur de vouloir restaurer la revision <code>{revision}</code> ?",
-    "seeing old revision": "Vous visualisez une ancienne revision : {revision}"
+    "seeing old revision": "Vous visualisez une ancienne revision : {revision}",
+    "template export": "Êtes vous sûr de vouloir exporter <code>{templateCount}</code> template(s)?",
+    "templates exported": "Templates exportés",
+    "flow export": "Êtes vous sûr de vouloir exporter <code>{flowCount}</code> flow(s)?",
+    "flows exported": "Flows exportés"
   },
   "de": {
     "id": "Id",
@@ -817,6 +825,10 @@
     "execution not found": "Ausführung <code>{executionId}</code> nicht gefunden",
     "execution not in state FAILED": "Ausführung <code>{executionId}</code> nicht im Status FAILED",
     "execution already finished": "Ausführung <code>{executionId}</code> bereits abgeschlossen",
-    "seeing old revision": "Sie sehen eine alte Revision: {revision}"
+    "seeing old revision": "Sie sehen eine alte Revision: {revision}",
+    "template export": "Are you sure you want to export <code>{templateCount}</code> template(s)?",
+    "templates exported": "Templates exported",
+    "flow export": "Are you sure you want to export <code>{flowCount}</code> flow(s)?",
+    "flows exported": "Flows exported"
   }
 }
diff --git a/ui/src/utils/utils.js b/ui/src/utils/utils.js
index 0477dd0a0d5..554b9662065 100644
--- a/ui/src/utils/utils.js
+++ b/ui/src/utils/utils.js
@@ -139,4 +139,12 @@ export default class Utils {
         throw new Error("Bad Hex");
     }
 
+    static downloadUrl(url, filename) {
+        const link = document.createElement("a");
+        link.href = url;
+        link.setAttribute("download", filename);
+        document.body.appendChild(link);
+        link.click();
+    }
+
 }

From a70fb3e01a5fbcbfa4238c80e2e7f046ceccb7ce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Lo=C3=AFc=20Mathieu?= <loikeseke@gmail.com>
Date: Mon, 20 Feb 2023 11:47:37 +0100
Subject: [PATCH 7/9] fix: rename extract to export

---
 ...d.java => FlowNamespaceExportCommand.java} | 14 +++++------
 ...va => TemplateNamespaceExportCommand.java} | 23 ++++++-------------
 ...va => FlowNamespaceExportCommandTest.java} |  8 +++----
 ...> TemplateNamespaceExportCommandTest.java} | 10 ++++----
 ui/src/stores/flow.js                         |  4 ++--
 ui/src/stores/template.js                     |  4 ++--
 .../webserver/controllers/FlowController.java | 12 +++++-----
 .../controllers/TemplateController.java       | 12 +++++-----
 .../controllers/FlowControllerTest.java       |  8 +++----
 .../controllers/TemplateControllerTest.java   |  8 +++----
 10 files changed, 47 insertions(+), 56 deletions(-)
 rename cli/src/main/java/io/kestra/cli/commands/flows/namespaces/{FlowNamespaceExtractCommand.java => FlowNamespaceExportCommand.java} (80%)
 rename cli/src/main/java/io/kestra/cli/commands/templates/namespaces/{TemplateNamespaceExtractCommand.java => TemplateNamespaceExportCommand.java} (66%)
 rename cli/src/test/java/io/kestra/cli/commands/flows/namespaces/{FlowNamespaceExtractCommandTest.java => FlowNamespaceExportCommandTest.java} (91%)
 rename cli/src/test/java/io/kestra/cli/commands/templates/namespaces/{TemplateNamespaceExtractCommandTest.java => TemplateNamespaceExportCommandTest.java} (86%)

diff --git a/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java b/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommand.java
similarity index 80%
rename from cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java
rename to cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommand.java
index 0c6f5b6984b..88aa8196573 100644
--- a/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommand.java
+++ b/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommand.java
@@ -15,18 +15,18 @@
 import java.nio.file.Path;
 
 @CommandLine.Command(
-    name = "extract",
-    description = "extract namespace flows",
+    name = "export",
+    description = "export namespace flows",
     mixinStandardHelpOptions = true
 )
 @Slf4j
-public class FlowNamespaceExtractCommand extends AbstractApiCommand {
+public class FlowNamespaceExportCommand extends AbstractApiCommand {
     private static final String DEFAULT_FILE_NAME = "flows.zip";
 
-    @CommandLine.Parameters(index = "0", description = "the namespace of templates to extract")
+    @CommandLine.Parameters(index = "0", description = "the namespace of templates to export")
     public String namespace;
 
-    @CommandLine.Parameters(index = "1", description = "the directory to extract the file to")
+    @CommandLine.Parameters(index = "1", description = "the directory to export the file to")
     public Path directory;
 
     @Override
@@ -35,14 +35,14 @@ public Integer call() throws Exception {
 
         try(DefaultHttpClient client = client()) {
             MutableHttpRequest<Object> request = HttpRequest
-                .GET("/api/v1/flows/extract/by-query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
+                .GET("/api/v1/flows/export/by-query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
 
             HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
             Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
             zipFile.toFile().createNewFile();
             Files.write(zipFile, response.body());
 
-            stdOut("Extracted flow(s) for namespace '" + namespace + "' successfully done !");
+            stdOut("Exporting flow(s) for namespace '" + namespace + "' successfully done !");
         } catch (HttpClientResponseException e) {
             FlowValidateCommand.handleHttpException(e, "flow");
             return 1;
diff --git a/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java b/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommand.java
similarity index 66%
rename from cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java
rename to cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommand.java
index c82f1415412..453403d3ebb 100644
--- a/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommand.java
+++ b/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommand.java
@@ -1,41 +1,32 @@
 package io.kestra.cli.commands.templates.namespaces;
 
 import io.kestra.cli.AbstractApiCommand;
-import io.kestra.cli.commands.AbstractServiceNamespaceUpdateCommand;
-import io.kestra.cli.commands.flows.FlowValidateCommand;
 import io.kestra.cli.commands.templates.TemplateValidateCommand;
-import io.kestra.core.models.templates.Template;
-import io.kestra.core.serializers.YamlFlowParser;
-import io.micronaut.core.type.Argument;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.HttpResponse;
 import io.micronaut.http.MediaType;
 import io.micronaut.http.MutableHttpRequest;
 import io.micronaut.http.client.exceptions.HttpClientResponseException;
 import io.micronaut.http.client.netty.DefaultHttpClient;
-import jakarta.inject.Inject;
 import lombok.extern.slf4j.Slf4j;
 import picocli.CommandLine;
 
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.List;
-import java.util.stream.Collectors;
-import javax.validation.ConstraintViolationException;
 
 @CommandLine.Command(
-    name = "extract",
-    description = "extract namespace templates",
+    name = "export",
+    description = "export namespace templates",
     mixinStandardHelpOptions = true
 )
 @Slf4j
-public class TemplateNamespaceExtractCommand extends AbstractApiCommand {
+public class TemplateNamespaceExportCommand extends AbstractApiCommand {
     private static final String DEFAULT_FILE_NAME = "templates.zip";
 
-    @CommandLine.Parameters(index = "0", description = "the namespace of templates to extract")
+    @CommandLine.Parameters(index = "0", description = "the namespace of templates to export")
     public String namespace;
 
-    @CommandLine.Parameters(index = "1", description = "the directory to extract the file to")
+    @CommandLine.Parameters(index = "1", description = "the directory to export the file to")
     public Path directory;
 
     @Override
@@ -44,14 +35,14 @@ public Integer call() throws Exception {
 
         try(DefaultHttpClient client = client()) {
             MutableHttpRequest<Object> request = HttpRequest
-                .GET("/api/v1/templates/extract/by-query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
+                .GET("/api/v1/templates/export/by-query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
 
             HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
             Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
             zipFile.toFile().createNewFile();
             Files.write(zipFile, response.body());
 
-            stdOut("Extracted template(s) for namespace '" + namespace + "' successfully done !");
+            stdOut("Exporting template(s) for namespace '" + namespace + "' successfully done !");
         } catch (HttpClientResponseException e) {
             TemplateValidateCommand.handleHttpException(e, "template");
             return 1;
diff --git a/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommandTest.java b/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommandTest.java
similarity index 91%
rename from cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommandTest.java
rename to cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommandTest.java
index 92a5db02d69..49611f46ff2 100644
--- a/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExtractCommandTest.java
+++ b/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommandTest.java
@@ -17,7 +17,7 @@
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.core.StringContains.containsString;
 
-class FlowNamespaceExtractCommandTest {
+class FlowNamespaceExportCommandTest {
     @Test
     void run() throws IOException {
         URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows");
@@ -42,8 +42,8 @@ void run() throws IOException {
             PicocliRunner.call(FlowNamespaceUpdateCommand.class, ctx, updateArgs);
             assertThat(out.toString(), containsString("3 flow(s)"));
 
-            // then we extract them
-            String[] extractArgs = {
+            // then we export them
+            String[] exportArgs = {
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -51,7 +51,7 @@ void run() throws IOException {
                 "io.kestra.cli",
                 "/tmp",
             };
-            PicocliRunner.call(FlowNamespaceExtractCommand.class, ctx, extractArgs);
+            PicocliRunner.call(FlowNamespaceExportCommand.class, ctx, exportArgs);
             File file = new File("/tmp/flows.zip");
             assertThat(file.exists(), is(true));
             ZipFile zipFile = new ZipFile(file);
diff --git a/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommandTest.java b/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommandTest.java
similarity index 86%
rename from cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommandTest.java
rename to cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommandTest.java
index 9e1b9f6012a..92e2ded7503 100644
--- a/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExtractCommandTest.java
+++ b/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommandTest.java
@@ -17,10 +17,10 @@
 import static org.hamcrest.core.StringContains.containsString;
 import static org.hamcrest.core.Is.is;
 
-class TemplateNamespaceExtractCommandTest {
+class TemplateNamespaceExportCommandTest {
     @Test
     void run() throws IOException {
-        URL directory = TemplateNamespaceExtractCommandTest.class.getClassLoader().getResource("templates");
+        URL directory = TemplateNamespaceExportCommandTest.class.getClassLoader().getResource("templates");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
 
@@ -42,8 +42,8 @@ void run() throws IOException {
             PicocliRunner.call(TemplateNamespaceUpdateCommand.class, ctx, args);
             assertThat(out.toString(), containsString("3 template(s)"));
 
-            // then we extract them
-            String[] extractArgs = {
+            // then we export them
+            String[] exportArgs = {
                 "--server",
                 embeddedServer.getURL().toString(),
                 "--user",
@@ -51,7 +51,7 @@ void run() throws IOException {
                 "io.kestra.tests",
                 "/tmp",
             };
-            PicocliRunner.call(TemplateNamespaceExtractCommand.class, ctx, extractArgs);
+            PicocliRunner.call(TemplateNamespaceExportCommand.class, ctx, exportArgs);
             File file = new File("/tmp/templates.zip");
             assertThat(file.exists(), is(true));
             ZipFile zipFile = new ZipFile(file);
diff --git a/ui/src/stores/flow.js b/ui/src/stores/flow.js
index 0117c2782de..84e2b5bed78 100644
--- a/ui/src/stores/flow.js
+++ b/ui/src/stores/flow.js
@@ -136,7 +136,7 @@ export default {
             })
         },
         exportFlowByIds(_, options) {
-            return this.$http.post("/api/v1/flows/extract/by-ids", options.ids, {responseType: "blob"})
+            return this.$http.post("/api/v1/flows/export/by-ids", options.ids, {responseType: "blob"})
                 .then(response => {
                     const blob = new Blob([response.data], {type: "application/octet-stream"});
                     const url = window.URL.createObjectURL(blob)
@@ -144,7 +144,7 @@ export default {
                 });
         },
         exportFlowByQuery(_, options) {
-            return this.$http.get("/api/v1/flows/extract/by-query", {params: options})
+            return this.$http.get("/api/v1/flows/export/by-query", {params: options})
                 .then(response => {
                     Utils.downloadUrl(response.request.responseURL, "flows.zip");
                 });
diff --git a/ui/src/stores/template.js b/ui/src/stores/template.js
index 314baeee4c0..b9c62ed9e96 100644
--- a/ui/src/stores/template.js
+++ b/ui/src/stores/template.js
@@ -60,7 +60,7 @@ export default {
             })
         },
         exportTemplateByIds(_, options) {
-            return this.$http.post("/api/v1/templates/extract/by-ids", options.ids, {responseType: "blob"})
+            return this.$http.post("/api/v1/templates/export/by-ids", options.ids, {responseType: "blob"})
                 .then(response => {
                     const blob = new Blob([response.data], {type: "application/octet-stream"});
                     const url = window.URL.createObjectURL(blob)
@@ -68,7 +68,7 @@ export default {
                 });
         },
         exportTemplateByQuery(_, options) {
-            return this.$http.get("/api/v1/templates/extract/by-query", {params: options})
+            return this.$http.get("/api/v1/templates/export/by-query", {params: options})
                 .then(response => {
                     Utils.downloadUrl(response.request.responseURL, "templates.zip");
                 });
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
index 2eb092f0474..68e9b78cc8b 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
@@ -449,12 +449,12 @@ public List<ValidateConstraintViolation> validateFlows(
     }
 
     @ExecuteOn(TaskExecutors.IO)
-    @Get(uri = "/extract/by-query", produces = MediaType.APPLICATION_OCTET_STREAM)
+    @Get(uri = "/export/by-query", produces = MediaType.APPLICATION_OCTET_STREAM)
     @Operation(
         tags = {"Flows"},
-        summary = "Extract flows as a ZIP archive of yaml sources."
+        summary = "Export flows as a ZIP archive of yaml sources."
     )
-    public HttpResponse<byte[]> extractByQuery(
+    public HttpResponse<byte[]> exportByQuery(
         @Parameter(description = "A string filter") @Nullable @QueryValue(value = "q") String query,
         @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue String namespace,
         @Parameter(description = "A labels filter") @Nullable @QueryValue List<String> labels
@@ -465,12 +465,12 @@ public HttpResponse<byte[]> extractByQuery(
     }
 
     @ExecuteOn(TaskExecutors.IO)
-    @Post(uri = "/extract/by-ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
+    @Post(uri = "/export/by-ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
     @Operation(
         tags = {"Flows"},
-        summary = "Extract flows as a ZIP archive of yaml sources."
+        summary = "Export flows as a ZIP archive of yaml sources."
     )
-    public HttpResponse<byte[]> extractByIds(
+    public HttpResponse<byte[]> exportByIds(
         @Parameter(description = "A list of tuple flow ID and namespace as flow identifiers") @Body List<IdWithNamespace> ids
     ) throws IOException {
         var flows = ids.stream()
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
index 4d64951402a..c4c43d7d2e3 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
@@ -248,11 +248,11 @@ public List<ValidateConstraintViolation> validateTemplates(
     }
 
     @ExecuteOn(TaskExecutors.IO)
-    @Get(uri = "/extract/by-query", produces = MediaType.APPLICATION_OCTET_STREAM)
+    @Get(uri = "/export/by-query", produces = MediaType.APPLICATION_OCTET_STREAM)
     @Operation(
-        summary = "Extract templates as a ZIP archive of yaml sources."
+        summary = "Export templates as a ZIP archive of yaml sources."
     )
-    public HttpResponse<byte[]> extractByQuery(
+    public HttpResponse<byte[]> exportByQuery(
         @Parameter(description = "A string filter") @Nullable @QueryValue(value = "q") String query,
         @Parameter(description = "A namespace filter prefix") @Nullable @QueryValue String namespace
     ) throws IOException {
@@ -262,11 +262,11 @@ public HttpResponse<byte[]> extractByQuery(
     }
 
     @ExecuteOn(TaskExecutors.IO)
-    @Post(uri = "/extract/by-ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
+    @Post(uri = "/export/by-ids", produces = MediaType.APPLICATION_OCTET_STREAM, consumes = MediaType.APPLICATION_JSON)
     @Operation(
-        summary = "Extract templates as a ZIP archive of yaml sources."
+        summary = "Export templates as a ZIP archive of yaml sources."
     )
-    public HttpResponse<byte[]> extractByIds(
+    public HttpResponse<byte[]> exportByIds(
         @Parameter(description = "A list of tuple flow ID and namespace as template identifiers") @Body List<IdWithNamespace> ids
     ) throws IOException {
         var templates = ids.stream()
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
index 6114bc1d15d..0307ccbe90b 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/FlowControllerTest.java
@@ -457,8 +457,8 @@ void updateInvalidFlowFromString() throws IOException {
     }
 
     @Test
-    void extractByQuery() throws IOException {
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/flows/extract/by-query?namespace=io.kestra.tests"),
+    void exportByQuery() throws IOException {
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/flows/export/by-query?namespace=io.kestra.tests"),
             Argument.of(byte[].class));
         File file = File.createTempFile("flows", ".zip");
         Files.write(file.toPath(), zip);
@@ -471,12 +471,12 @@ void extractByQuery() throws IOException {
     }
 
     @Test
-    void extractByIds() throws IOException {
+    void exportByIds() throws IOException {
         List<IdWithNamespace> ids = List.of(
             new IdWithNamespace("io.kestra.tests", "each-object"),
             new IdWithNamespace("io.kestra.tests", "webhook"),
             new IdWithNamespace("io.kestra.tests", "task-flow"));
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/flows/extract/by-ids", ids),
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/flows/export/by-ids", ids),
             Argument.of(byte[].class));
         File file = File.createTempFile("flows", ".zip");
         Files.write(file.toPath(), zip);
diff --git a/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java b/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
index 423da09849b..7580ac56121 100644
--- a/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
+++ b/webserver/src/test/java/io/kestra/webserver/controllers/TemplateControllerTest.java
@@ -129,14 +129,14 @@ void listDistinctNamespace() {
     }
 
     @Test
-    void extractByQuery() throws IOException {
+    void exportByQuery() throws IOException {
         // create 3 templates, so we have at least 3 of them
         client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
         client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
         client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
         int size = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/templates/search?namespace=kestra.test"), Argument.of(PagedResults.class, Template.class)).getResults().size();
 
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/templates/extract/by-query?namespace=kestra.test"),
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.GET("/api/v1/templates/export/by-query?namespace=kestra.test"),
             Argument.of(byte[].class));
         File file = File.createTempFile("templates", ".zip");
         Files.write(file.toPath(), zip);
@@ -149,7 +149,7 @@ void extractByQuery() throws IOException {
     }
 
     @Test
-    void extractByIds() throws IOException {
+    void exportByIds() throws IOException {
         // create 3 templates, so we can retrieve them by id
         var template1 = client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
         var template2 = client.toBlocking().retrieve(POST("/api/v1/templates", createTemplate()), Template.class);
@@ -159,7 +159,7 @@ void extractByIds() throws IOException {
             new IdWithNamespace("kestra.test", template1.getId()),
             new IdWithNamespace("kestra.test", template2.getId()),
             new IdWithNamespace("kestra.test", template3.getId()));
-        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/templates/extract/by-ids?namespace=kestra.test", ids),
+        byte[] zip = client.toBlocking().retrieve(HttpRequest.POST("/api/v1/templates/export/by-ids?namespace=kestra.test", ids),
             Argument.of(byte[].class));
         File file = File.createTempFile("templates", ".zip");
         Files.write(file.toPath(), zip);

From cf5bc7a756248a4f033b3bb7dce4fdba6a71f013 Mon Sep 17 00:00:00 2001
From: Ludovic DEHON <tchiot.ludo@gmail.com>
Date: Mon, 20 Feb 2023 23:05:10 +0100
Subject: [PATCH 8/9] cleanup

---
 .../cli/commands/flows/FlowCommand.java       |  3 +-
 ...ortCommand.java => FlowExportCommand.java} | 14 ++++-----
 .../commands/templates/TemplateCommand.java   |  3 +-
 ...ommand.java => TemplateExportCommand.java} | 15 +++++-----
 ...ndTest.java => FlowExportCommandTest.java} | 12 ++++----
 ...st.java => TemplateExportCommandTest.java} | 10 ++++---
 .../core/models/templates/Template.java       |  1 -
 ui/src/components/flows/Flows.vue             |  2 +-
 ui/src/components/templates/Templates.vue     |  2 +-
 ui/src/stores/flow.js                         | 29 ++++++++++---------
 ui/src/translations.json                      | 11 ++++---
 ui/src/utils/utils.js                         |  1 -
 .../webserver/controllers/FlowController.java |  3 +-
 .../controllers/TemplateController.java       |  2 +-
 14 files changed, 57 insertions(+), 51 deletions(-)
 rename cli/src/main/java/io/kestra/cli/commands/flows/{namespaces/FlowNamespaceExportCommand.java => FlowExportCommand.java} (74%)
 rename cli/src/main/java/io/kestra/cli/commands/templates/{namespaces/TemplateNamespaceExportCommand.java => TemplateExportCommand.java} (73%)
 rename cli/src/test/java/io/kestra/cli/commands/flows/{namespaces/FlowNamespaceExportCommandTest.java => FlowExportCommandTest.java} (85%)
 rename cli/src/test/java/io/kestra/cli/commands/templates/{namespaces/TemplateNamespaceExportCommandTest.java => TemplateExportCommandTest.java} (84%)

diff --git a/cli/src/main/java/io/kestra/cli/commands/flows/FlowCommand.java b/cli/src/main/java/io/kestra/cli/commands/flows/FlowCommand.java
index f66c3e03d37..21af348e45d 100644
--- a/cli/src/main/java/io/kestra/cli/commands/flows/FlowCommand.java
+++ b/cli/src/main/java/io/kestra/cli/commands/flows/FlowCommand.java
@@ -16,7 +16,8 @@
         FlowValidateCommand.class,
         FlowTestCommand.class,
         FlowNamespaceCommand.class,
-        FlowDotCommand.class
+        FlowDotCommand.class,
+        FlowExportCommand.class,
     }
 )
 @Slf4j
diff --git a/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommand.java b/cli/src/main/java/io/kestra/cli/commands/flows/FlowExportCommand.java
similarity index 74%
rename from cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommand.java
rename to cli/src/main/java/io/kestra/cli/commands/flows/FlowExportCommand.java
index 88aa8196573..cb8199454b1 100644
--- a/cli/src/main/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommand.java
+++ b/cli/src/main/java/io/kestra/cli/commands/flows/FlowExportCommand.java
@@ -1,7 +1,6 @@
-package io.kestra.cli.commands.flows.namespaces;
+package io.kestra.cli.commands.flows;
 
 import io.kestra.cli.AbstractApiCommand;
-import io.kestra.cli.commands.flows.FlowValidateCommand;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.HttpResponse;
 import io.micronaut.http.MediaType;
@@ -16,17 +15,17 @@
 
 @CommandLine.Command(
     name = "export",
-    description = "export namespace flows",
+    description = "export flows to a zip file",
     mixinStandardHelpOptions = true
 )
 @Slf4j
-public class FlowNamespaceExportCommand extends AbstractApiCommand {
+public class FlowExportCommand extends AbstractApiCommand {
     private static final String DEFAULT_FILE_NAME = "flows.zip";
 
-    @CommandLine.Parameters(index = "0", description = "the namespace of templates to export")
+    @CommandLine.Option(names = {"--namespace"}, description = "the namespace of flows to export")
     public String namespace;
 
-    @CommandLine.Parameters(index = "1", description = "the directory to export the file to")
+    @CommandLine.Parameters(index = "0", description = "the directory to export the file to")
     public Path directory;
 
     @Override
@@ -35,7 +34,8 @@ public Integer call() throws Exception {
 
         try(DefaultHttpClient client = client()) {
             MutableHttpRequest<Object> request = HttpRequest
-                .GET("/api/v1/flows/export/by-query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
+                .GET("/api/v1/flows/export/by-query" + (namespace != null ? "?namespace=" + namespace : ""))
+                .accept(MediaType.APPLICATION_OCTET_STREAM);
 
             HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
             Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
diff --git a/cli/src/main/java/io/kestra/cli/commands/templates/TemplateCommand.java b/cli/src/main/java/io/kestra/cli/commands/templates/TemplateCommand.java
index 681cba1c6d8..b65362b031d 100644
--- a/cli/src/main/java/io/kestra/cli/commands/templates/TemplateCommand.java
+++ b/cli/src/main/java/io/kestra/cli/commands/templates/TemplateCommand.java
@@ -14,7 +14,8 @@
     mixinStandardHelpOptions = true,
     subcommands = {
         TemplateNamespaceCommand.class,
-        TemplateValidateCommand.class
+        TemplateValidateCommand.class,
+        TemplateExportCommand.class,
     }
 )
 @Slf4j
diff --git a/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommand.java b/cli/src/main/java/io/kestra/cli/commands/templates/TemplateExportCommand.java
similarity index 73%
rename from cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommand.java
rename to cli/src/main/java/io/kestra/cli/commands/templates/TemplateExportCommand.java
index 453403d3ebb..68d7f471e65 100644
--- a/cli/src/main/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommand.java
+++ b/cli/src/main/java/io/kestra/cli/commands/templates/TemplateExportCommand.java
@@ -1,7 +1,6 @@
-package io.kestra.cli.commands.templates.namespaces;
+package io.kestra.cli.commands.templates;
 
 import io.kestra.cli.AbstractApiCommand;
-import io.kestra.cli.commands.templates.TemplateValidateCommand;
 import io.micronaut.http.HttpRequest;
 import io.micronaut.http.HttpResponse;
 import io.micronaut.http.MediaType;
@@ -16,17 +15,17 @@
 
 @CommandLine.Command(
     name = "export",
-    description = "export namespace templates",
+    description = "export templates to a zip file",
     mixinStandardHelpOptions = true
 )
 @Slf4j
-public class TemplateNamespaceExportCommand extends AbstractApiCommand {
+public class TemplateExportCommand extends AbstractApiCommand {
     private static final String DEFAULT_FILE_NAME = "templates.zip";
 
-    @CommandLine.Parameters(index = "0", description = "the namespace of templates to export")
+    @CommandLine.Option(names = {"--namespace"}, description = "the namespace of templates to export")
     public String namespace;
 
-    @CommandLine.Parameters(index = "1", description = "the directory to export the file to")
+    @CommandLine.Parameters(index = "0", description = "the directory to export the file to")
     public Path directory;
 
     @Override
@@ -35,7 +34,8 @@ public Integer call() throws Exception {
 
         try(DefaultHttpClient client = client()) {
             MutableHttpRequest<Object> request = HttpRequest
-                .GET("/api/v1/templates/export/by-query?namespace=" + namespace).accept(MediaType.APPLICATION_OCTET_STREAM);
+                .GET("/api/v1/templates/export/by-query" + (namespace != null ? "?namespace=" + namespace : ""))
+                .accept(MediaType.APPLICATION_OCTET_STREAM);
 
             HttpResponse<byte[]> response = client.toBlocking().exchange(this.requestOptions(request), byte[].class);
             Path zipFile = Path.of(directory.toString(), DEFAULT_FILE_NAME);
@@ -50,5 +50,4 @@ public Integer call() throws Exception {
 
         return 0;
     }
-
 }
diff --git a/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommandTest.java b/cli/src/test/java/io/kestra/cli/commands/flows/FlowExportCommandTest.java
similarity index 85%
rename from cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommandTest.java
rename to cli/src/test/java/io/kestra/cli/commands/flows/FlowExportCommandTest.java
index 49611f46ff2..407d90ef73e 100644
--- a/cli/src/test/java/io/kestra/cli/commands/flows/namespaces/FlowNamespaceExportCommandTest.java
+++ b/cli/src/test/java/io/kestra/cli/commands/flows/FlowExportCommandTest.java
@@ -1,5 +1,6 @@
-package io.kestra.cli.commands.flows.namespaces;
+package io.kestra.cli.commands.flows;
 
+import io.kestra.cli.commands.flows.namespaces.FlowNamespaceUpdateCommand;
 import io.micronaut.configuration.picocli.PicocliRunner;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.env.Environment;
@@ -17,15 +18,14 @@
 import static org.hamcrest.core.Is.is;
 import static org.hamcrest.core.StringContains.containsString;
 
-class FlowNamespaceExportCommandTest {
+class FlowExportCommandTest {
     @Test
     void run() throws IOException {
-        URL directory = FlowNamespaceUpdateCommandTest.class.getClassLoader().getResource("flows");
+        URL directory = FlowExportCommandTest.class.getClassLoader().getResource("flows");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
 
         try (ApplicationContext ctx = ApplicationContext.run(Environment.CLI, Environment.TEST)) {
-
             EmbeddedServer embeddedServer = ctx.getBean(EmbeddedServer.class);
             embeddedServer.start();
 
@@ -37,7 +37,6 @@ void run() throws IOException {
                 "myuser:pass:word",
                 "io.kestra.cli",
                 directory.getPath(),
-
             };
             PicocliRunner.call(FlowNamespaceUpdateCommand.class, ctx, updateArgs);
             assertThat(out.toString(), containsString("3 flow(s)"));
@@ -48,10 +47,11 @@ void run() throws IOException {
                 embeddedServer.getURL().toString(),
                 "--user",
                 "myuser:pass:word",
+                "--namespace",
                 "io.kestra.cli",
                 "/tmp",
             };
-            PicocliRunner.call(FlowNamespaceExportCommand.class, ctx, exportArgs);
+            PicocliRunner.call(FlowExportCommand.class, ctx, exportArgs);
             File file = new File("/tmp/flows.zip");
             assertThat(file.exists(), is(true));
             ZipFile zipFile = new ZipFile(file);
diff --git a/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommandTest.java b/cli/src/test/java/io/kestra/cli/commands/templates/TemplateExportCommandTest.java
similarity index 84%
rename from cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommandTest.java
rename to cli/src/test/java/io/kestra/cli/commands/templates/TemplateExportCommandTest.java
index 92e2ded7503..a6bde6d2af7 100644
--- a/cli/src/test/java/io/kestra/cli/commands/templates/namespaces/TemplateNamespaceExportCommandTest.java
+++ b/cli/src/test/java/io/kestra/cli/commands/templates/TemplateExportCommandTest.java
@@ -1,5 +1,6 @@
-package io.kestra.cli.commands.templates.namespaces;
+package io.kestra.cli.commands.templates;
 
+import io.kestra.cli.commands.templates.namespaces.TemplateNamespaceUpdateCommand;
 import io.micronaut.configuration.picocli.PicocliRunner;
 import io.micronaut.context.ApplicationContext;
 import io.micronaut.context.env.Environment;
@@ -17,10 +18,10 @@
 import static org.hamcrest.core.StringContains.containsString;
 import static org.hamcrest.core.Is.is;
 
-class TemplateNamespaceExportCommandTest {
+class TemplateExportCommandTest {
     @Test
     void run() throws IOException {
-        URL directory = TemplateNamespaceExportCommandTest.class.getClassLoader().getResource("templates");
+        URL directory = TemplateExportCommandTest.class.getClassLoader().getResource("templates");
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         System.setOut(new PrintStream(out));
 
@@ -48,10 +49,11 @@ void run() throws IOException {
                 embeddedServer.getURL().toString(),
                 "--user",
                 "myuser:pass:word",
+                "--namespace",
                 "io.kestra.tests",
                 "/tmp",
             };
-            PicocliRunner.call(TemplateNamespaceExportCommand.class, ctx, exportArgs);
+            PicocliRunner.call(TemplateExportCommand.class, ctx, exportArgs);
             File file = new File("/tmp/templates.zip");
             assertThat(file.exists(), is(true));
             ZipFile zipFile = new ZipFile(file);
diff --git a/core/src/main/java/io/kestra/core/models/templates/Template.java b/core/src/main/java/io/kestra/core/models/templates/Template.java
index 001f3566b71..dcf4fdbb7dd 100644
--- a/core/src/main/java/io/kestra/core/models/templates/Template.java
+++ b/core/src/main/java/io/kestra/core/models/templates/Template.java
@@ -31,7 +31,6 @@
 @ToString
 @EqualsAndHashCode
 public class Template implements DeletedInterface {
-
     private static final ObjectMapper YAML_MAPPER = JacksonMapper.ofYaml().copy()
         .setAnnotationIntrospector(new JacksonAnnotationIntrospector() {
             @Override
diff --git a/ui/src/components/flows/Flows.vue b/ui/src/components/flows/Flows.vue
index cc50b70d55d..dfc8f8efc44 100644
--- a/ui/src/components/flows/Flows.vue
+++ b/ui/src/components/flows/Flows.vue
@@ -108,7 +108,7 @@
                     <bottom-line-counter v-model="queryBulkAction" :selections="flowsSelection" :total="total" @update:model-value="selectAll()" />
                     <li v-if="canRead">
                         <el-button :icon="Download" type="info" class="bulk-button" @click="exportFlows()">
-                            {{ $t('exports') }}
+                            {{ $t('export') }}
                         </el-button>
                     </li>
                 </ul>
diff --git a/ui/src/components/templates/Templates.vue b/ui/src/components/templates/Templates.vue
index 6fdd997a614..8c7707cc97f 100644
--- a/ui/src/components/templates/Templates.vue
+++ b/ui/src/components/templates/Templates.vue
@@ -68,7 +68,7 @@
                     <bottom-line-counter v-model="queryBulkAction" :selections="templatesSelection" :total="total" @update:model-value="selectAll()" />
                     <li v-if="canRead">
                         <el-button :icon="Download" type="info" class="bulk-button" @click="exportTemplates()">
-                            {{ $t('exports') }}
+                            {{ $t('export') }}
                         </el-button>
                     </li>
                 </ul>
diff --git a/ui/src/stores/flow.js b/ui/src/stores/flow.js
index 84e2b5bed78..23b40c4030f 100644
--- a/ui/src/stores/flow.js
+++ b/ui/src/stores/flow.js
@@ -50,21 +50,22 @@ export default {
                     validateStatus: (status) => {
                         return options.deleted ? status === 200 || status === 404 : status === 200;
                     }
-                }).then(response => {
-                if (response.data.exception) {
-                    commit("core/setMessage", {
-                        title: "Invalid source code",
-                        message: response.data.exception,
-                        variant: "danger"
-                    }, {root: true});
-                    delete response.data.exception;
-                    commit("setFlow", JSON.parse(response.data.source));
-                } else {
-                    commit("setFlow", response.data);
-                }
+                })
+                .then(response => {
+                    if (response.data.exception) {
+                        commit("core/setMessage", {
+                            title: "Invalid source code",
+                            message: response.data.exception,
+                            variant: "danger"
+                        }, {root: true});
+                        delete response.data.exception;
+                        commit("setFlow", JSON.parse(response.data.source));
+                    } else {
+                        commit("setFlow", response.data);
+                    }
 
-                return response.data;
-            })
+                    return response.data;
+                })
         },
         loadTask({commit}, options) {
             return this.$http.get(`/api/v1/flows/${options.namespace}/${options.id}/tasks/${options.taskId}${options.revision ? "?revision=" + options.revision : ""}`).then(response => {
diff --git a/ui/src/translations.json b/ui/src/translations.json
index e987e7ba5c1..555e744d1c8 100644
--- a/ui/src/translations.json
+++ b/ui/src/translations.json
@@ -271,6 +271,7 @@
     "execution not in state FAILED": "Execution <code>{executionId}</code> not in state FAILED",
     "execution already finished": "Execution <code>{executionId}</code> already finished",
     "seeing old revision": "You are seeing an old revision: {revision}",
+    "export": "Export",
     "template export": "Are you sure you want to export <code>{templateCount}</code> template(s)?",
     "templates exported": "Templates exported",
     "flow export": "Are you sure you want to export <code>{flowCount}</code> flow(s)?",
@@ -549,6 +550,7 @@
     "execution already finished": "Execution <code>{executionId}</code> déjà terminée",
     "restore revision": "Êtes-vous sur de vouloir restaurer la revision <code>{revision}</code> ?",
     "seeing old revision": "Vous visualisez une ancienne revision : {revision}",
+    "export": "Exporter",
     "template export": "Êtes vous sûr de vouloir exporter <code>{templateCount}</code> template(s)?",
     "templates exported": "Templates exportés",
     "flow export": "Êtes vous sûr de vouloir exporter <code>{flowCount}</code> flow(s)?",
@@ -826,9 +828,10 @@
     "execution not in state FAILED": "Ausführung <code>{executionId}</code> nicht im Status FAILED",
     "execution already finished": "Ausführung <code>{executionId}</code> bereits abgeschlossen",
     "seeing old revision": "Sie sehen eine alte Revision: {revision}",
-    "template export": "Are you sure you want to export <code>{templateCount}</code> template(s)?",
-    "templates exported": "Templates exported",
-    "flow export": "Are you sure you want to export <code>{flowCount}</code> flow(s)?",
-    "flows exported": "Flows exported"
+    "export": "Export",
+    "template export": "Sind Sie sicher, dass Sie <code>{templateCount}</code> Template(n) exportieren möchten?",
+    "templates exported": "Template exportiert",
+    "flow export": "Sind Sie sicher, dass Sie <code>{flowCount}</code> Flows exportieren möchten?",
+    "flows exported": "Flows exportiert"
   }
 }
diff --git a/ui/src/utils/utils.js b/ui/src/utils/utils.js
index 554b9662065..4708d32b526 100644
--- a/ui/src/utils/utils.js
+++ b/ui/src/utils/utils.js
@@ -146,5 +146,4 @@ export default class Utils {
         document.body.appendChild(link);
         link.click();
     }
-
 }
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
index 68e9b78cc8b..9b5d45ee573 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/FlowController.java
@@ -461,6 +461,7 @@ public HttpResponse<byte[]> exportByQuery(
     ) throws IOException {
         var flows = flowRepository.findWithSource(query, namespace, RequestUtils.toMap(labels));
         var bytes = zipFlows(flows);
+
         return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"flows.zip\"");
     }
 
@@ -480,7 +481,7 @@ public HttpResponse<byte[]> exportByIds(
         return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"flows.zip\"");
     }
 
-    private byte[] zipFlows(List<FlowWithSource> flows) throws IOException {
+    private static byte[] zipFlows(List<FlowWithSource> flows) throws IOException {
         try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ZipOutputStream archive = new ZipOutputStream(bos)) {
 
diff --git a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
index c4c43d7d2e3..c790a67ee71 100644
--- a/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
+++ b/webserver/src/main/java/io/kestra/webserver/controllers/TemplateController.java
@@ -276,7 +276,7 @@ public HttpResponse<byte[]> exportByIds(
         return HttpResponse.ok(bytes).header("Content-Disposition", "attachment; filename=\"templates.zip\"");
     }
 
-    private byte[] zipTemplates(List<Template> templates) throws IOException {
+    private static byte[] zipTemplates(List<Template> templates) throws IOException {
         try(ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ZipOutputStream archive = new ZipOutputStream(bos)) {
 

From b690831903cfae3bc0d1653f359095ad3e8994da Mon Sep 17 00:00:00 2001
From: Ludovic DEHON <tchiot.ludo@gmail.com>
Date: Tue, 21 Feb 2023 08:23:44 +0100
Subject: [PATCH 9/9] select all don't work

---
 ui/src/components/executions/Executions.vue | 4 +++-
 ui/src/components/flows/Flows.vue           | 8 +++++---
 ui/src/components/templates/Templates.vue   | 8 +++++---
 3 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/ui/src/components/executions/Executions.vue b/ui/src/components/executions/Executions.vue
index 80acbca2513..3c205aaff5b 100644
--- a/ui/src/components/executions/Executions.vue
+++ b/ui/src/components/executions/Executions.vue
@@ -244,7 +244,9 @@
                 this.executionsSelection = val.map(x => x.id);
             },
             selectAll() {
-                this.$refs.table.toggleAllSelection();
+                if (this.$refs.table.getSelectionRows().length !== this.$refs.table.data.length) {
+                    this.$refs.table.toggleAllSelection();
+                }
             },
             isRunning(item){
                 return State.isRunning(item.state.current);
diff --git a/ui/src/components/flows/Flows.vue b/ui/src/components/flows/Flows.vue
index dfc8f8efc44..b2f008d2165 100644
--- a/ui/src/components/flows/Flows.vue
+++ b/ui/src/components/flows/Flows.vue
@@ -221,7 +221,9 @@
                 });
             },
             selectAll() {
-                this.$refs.table.toggleAllSelection();
+                if (this.$refs.table.getSelectionRows().length !== this.$refs.table.data.length) {
+                    this.$refs.table.toggleAllSelection();
+                }
             },
             exportFlows() {
                 this.$toast().confirm(
@@ -230,8 +232,8 @@
                         if (this.queryBulkAction) {
                             return this.$store
                                 .dispatch("flow/exportFlowByQuery", this.loadQuery({
-                                    namespace: this.$route.query.namespace ? [this.$route.query.namespace] : "",
-                                    q: this.$route.query.q ? [this.$route.query.q] : "",
+                                    namespace: this.$route.query.namespace ? [this.$route.query.namespace] : undefined,
+                                    q: this.$route.query.q ? [this.$route.query.q] : undefined,
                                 }, false))
                                 .then(_ => {
                                     this.$toast().success(this.$t("flows exported"));
diff --git a/ui/src/components/templates/Templates.vue b/ui/src/components/templates/Templates.vue
index 8c7707cc97f..2f0afc3c14d 100644
--- a/ui/src/components/templates/Templates.vue
+++ b/ui/src/components/templates/Templates.vue
@@ -171,7 +171,9 @@
                 });
             },
             selectAll() {
-                this.$refs.table.toggleAllSelection();
+                if (this.$refs.table.getSelectionRows().length !== this.$refs.table.data.length) {
+                    this.$refs.table.toggleAllSelection();
+                }
             },
             exportTemplates() {
                 this.$toast().confirm(
@@ -180,8 +182,8 @@
                         if (this.queryBulkAction) {
                             return this.$store
                                 .dispatch("template/exportTemplateByQuery", this.loadQuery({
-                                    namespace: this.$route.query.namespace ? [this.$route.query.namespace] : "",
-                                    q: this.$route.query.q ? [this.$route.query.q] : "",
+                                    namespace: this.$route.query.namespace ? [this.$route.query.namespace] : undefined,
+                                    q: this.$route.query.q ? [this.$route.query.q] : undefined,
                                 }, false))
                                 .then(_ => {
                                     this.$toast().success(this.$t("templates exported"));