Add support for conditional scaffolding

src/ConductorSharp.Toolkit/Filters/ITaskFilter.cs

@@ -0,0 +1,9 @@
+using ConductorSharp.Client.Model.Common;
+
+namespace ConductorSharp.Toolkit.Filters
+{
+    public interface ITaskFilter
+    {
+        bool Test(TaskDefinition taskDefinition);
+    }
+}

src/ConductorSharp.Toolkit/Filters/IWorkflowFilter.cs

@@ -0,0 +1,9 @@
+using ConductorSharp.Client.Model.Common;
+
+namespace ConductorSharp.Toolkit.Filters
+{
+    public interface IWorkflowFilter
+    {
+        bool Test(WorkflowDefinition workflowDefinition);
+    }
+}

src/ConductorSharp.Toolkit/Filters/NameTaskFilter.cs

@@ -0,0 +1,15 @@
+using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Toolkit.Util;
+using System.Text.RegularExpressions;
+
+namespace ConductorSharp.Toolkit.Filters
+{
+    public class NameTaskFilter : ITaskFilter
+    {
+        private readonly Regex[] _regexes;
+
+        public NameTaskFilter(IEnumerable<string> names) => _regexes = names.Select(name => RegexUtil.CreateNameRegex(name)).ToArray();
+
+        public bool Test(TaskDefinition taskDefinition) => _regexes.Any(regex => regex.IsMatch(taskDefinition.Name));
+    }
+}

src/ConductorSharp.Toolkit/Filters/NameWorkflowFilter.cs

@@ -0,0 +1,15 @@
+using ConductorSharp.Client.Model.Common;
+using ConductorSharp.Toolkit.Util;
+using System.Text.RegularExpressions;
+
+namespace ConductorSharp.Toolkit.Filters
+{
+    public class NameWorkflowFilter : IWorkflowFilter
+    {
+        private readonly Regex[] _regexes;
+
+        public NameWorkflowFilter(IEnumerable<string> names) => _regexes = names.Select(name => RegexUtil.CreateNameRegex(name)).ToArray();
+
+        public bool Test(WorkflowDefinition workflowDefinition) => _regexes.Any(regex => regex.IsMatch(workflowDefinition.Name));
+    }
+}

src/ConductorSharp.Toolkit/Filters/OwnerAppTaskFilter.cs

@@ -0,0 +1,13 @@
+using ConductorSharp.Client.Model.Common;
+
+namespace ConductorSharp.Toolkit.Filters
+{
+    public class OwnerAppTaskFilter : ITaskFilter
+    {
+        private readonly string[] _ownerApps;
+
+        public OwnerAppTaskFilter(IEnumerable<string> ownerApps) => _ownerApps = ownerApps.ToArray();
+
+        public bool Test(TaskDefinition taskDefinition) => taskDefinition.OwnerApp != null && _ownerApps.Any(app => app == taskDefinition.OwnerApp);
+    }
+}

src/ConductorSharp.Toolkit/Filters/OwnerAppWorkflowFilter.cs

@@ -0,0 +1,14 @@
+using ConductorSharp.Client.Model.Common;
+
+namespace ConductorSharp.Toolkit.Filters
+{
+    public class OwnerAppWorkflowFilter : IWorkflowFilter
+    {
+        private readonly string[] _ownerApps;
+
+        public OwnerAppWorkflowFilter(IEnumerable<string> ownerApps) => _ownerApps = ownerApps.ToArray();
+
+        public bool Test(WorkflowDefinition workflowDefinition) =>
+            workflowDefinition.OwnerApp != null && _ownerApps.Any(app => app == workflowDefinition.OwnerApp);
+    }
+}

src/ConductorSharp.Toolkit/Filters/OwnerEmailTaskFilter.cs

@@ -0,0 +1,14 @@
+using ConductorSharp.Client.Model.Common;
+
+namespace ConductorSharp.Toolkit.Filters
+{
+    public class OwnerEmailTaskFilter : ITaskFilter
+    {
+        private readonly string[] _ownerEmails;
+
+        public OwnerEmailTaskFilter(IEnumerable<string> ownerEmails) => _ownerEmails = ownerEmails.ToArray();
+
+        public bool Test(TaskDefinition taskDefinition) =>
+            taskDefinition.OwnerEmail != null && _ownerEmails.Any(email => email == taskDefinition.OwnerEmail);
+    }
+}

src/ConductorSharp.Toolkit/Filters/OwnerEmailWorkflowFilter.cs

@@ -0,0 +1,14 @@
+using ConductorSharp.Client.Model.Common;
+
+namespace ConductorSharp.Toolkit.Filters
+{
+    public class OwnerEmailWorkflowFilter : IWorkflowFilter
+    {
+        private readonly string[] _ownerEmails;
+
+        public OwnerEmailWorkflowFilter(IEnumerable<string> ownerEmails) => _ownerEmails = ownerEmails.ToArray();
+
+        public bool Test(WorkflowDefinition workflowDefinition) =>
+            workflowDefinition.OwnerEmail != null && _ownerEmails.Any(email => email == workflowDefinition.OwnerEmail);
+    }
+}

src/ConductorSharp.Toolkit/Models/ToolkitOptions.cs

@@ -6,5 +6,23 @@ public class ToolkitOptions
     {
         [Option('f', "file", HelpText = "Configuration file", Default = "conductorsharp.yaml")]
         public string ConfigurationFilePath { get; set; }
+
+        [Option('n', "name", HelpText = "Specifies names of the tasks and workflows to scaffold")]
+        public IEnumerable<string> NameFilters { get; set; }
+
+        [Option('a', "app", HelpText = "Specifies owner apps of the tasks and workflows to scaffold")]
+        public IEnumerable<string> OwnerAppFilters { get; set; }
+
+        [Option('e', "email", HelpText = "Specifies owner emails of the tasks and workflows to scaffold")]
+        public IEnumerable<string> OwnerEmailFilters { get; set; }
+
+        [Option("no-tasks", Default = false, SetName = "no-tasks", HelpText = "Skip task scaffolding")]
+        public bool IgnoreTasks { get; set; }
+
+        [Option("no-workflows", Default = false, SetName = "no-workflows", HelpText = "Skip workflow scaffolding")]
+        public bool IgnoreWorkflows { get; set; }
+
+        [Option("dry-run", Default = false, HelpText = "Print which workflows would be scaffolded")]
+        public bool DryRun { get; set; }
     }
 }

src/ConductorSharp.Toolkit/Program.cs

@@ -61,7 +61,7 @@ private static async Task RunToolkit(ToolkitOptions options)
                 if (!ValidateConfiguration(config))
                     return;
 
-                var container = BuildContainer(config);
+                var container = BuildContainer(config, options);
                 var commandRegistry = container.Resolve<CommandRegistry>();
                 // Currently only scaffolding is supported
                 var command = commandRegistry.Get("scaffold");
@@ -104,7 +104,7 @@ private static bool ValidateConfiguration(Configuration config)
             return validConfiguration;
         }
 
-        private static IContainer BuildContainer(Configuration config)
+        private static IContainer BuildContainer(Configuration config, ToolkitOptions options)
         {
             var serviceCollection = new ServiceCollection();
 
@@ -118,6 +118,12 @@ private static IContainer BuildContainer(Configuration config)
                 scaffoldingConfig.BaseUrl = config.BaseUrl;
                 scaffoldingConfig.BaseNamespace = config.Namespace;
                 scaffoldingConfig.Destination = config.Destination;
+                scaffoldingConfig.NameFilters = options.NameFilters.ToArray();
+                scaffoldingConfig.OwnerAppFilters = options.OwnerAppFilters.ToArray();
+                scaffoldingConfig.OwnerEmailFilters = options.OwnerEmailFilters.ToArray();
+                scaffoldingConfig.IgnoreTasks = options.IgnoreTasks;
+                scaffoldingConfig.IgnoreWorkflows = options.IgnoreWorkflows;
+                scaffoldingConfig.DryRun = options.DryRun;
             });
 
             builder.Populate(serviceCollection);

src/ConductorSharp.Toolkit/ScaffoldingConfig.cs

@@ -5,7 +5,12 @@ public class ScaffoldingConfig
         public string BaseNamespace { get; set; }
         public string ApiUrl { get; set; }
         public string BaseUrl { get; set; }
-        public bool Dryrun { get; set; }
+        public bool DryRun { get; set; }
         public string Destination { get; set; }
+        public string[] NameFilters { get; set; }
+        public string[] OwnerAppFilters { get; set; }
+        public string[] OwnerEmailFilters { get; set; }
+        public bool IgnoreTasks { get; set; }
+        public bool IgnoreWorkflows { get; set; }
     }
 }

src/ConductorSharp.Toolkit/Service/ScaffoldingService.cs

@@ -1,6 +1,7 @@
 using ConductorSharp.Client.Model.Common;
 using ConductorSharp.Client.Service;
 using ConductorSharp.Engine.Util;
+using ConductorSharp.Toolkit.Filters;
 using ConductorSharp.Toolkit.Util;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -28,31 +29,50 @@ public ScaffoldingService(IMetadataService metadataService, IOptions<Scaffolding
 
         public async Task Scaffold()
         {
-            var workflowDefinitions = await _metadataService.GetAllWorkflowDefinitions();
-            var workflowDirectory = Path.Combine(_config.Destination, "Workflows");
-            Directory.CreateDirectory(workflowDirectory);
-            foreach (var workflowDefinition in workflowDefinitions)
-            {
-                (var contents, var modelClassName) = CreateWorkflowClass(workflowDefinition);
+            var taskFilters = CreateTaskFilters();
+            var workflowFilters = CreateWorkflowFilters();
 
-                if (contents != null)
+            if (!_config.IgnoreWorkflows)
+            {
+                var workflowDefinitions = await _metadataService.GetAllWorkflowDefinitions();
+                workflowDefinitions = Filter(workflowDefinitions, workflowFilters).ToArray();
+                var workflowDirectory = Path.Combine(_config.Destination, "Workflows");
+                Directory.CreateDirectory(workflowDirectory);
+                foreach (var workflowDefinition in workflowDefinitions)
                 {
-                    var filePath = Path.Combine(workflowDirectory, $"{modelClassName}.scaff.cs");
-                    File.WriteAllText(filePath, contents);
+                    Console.WriteLine($"Scaffolding workflow {workflowDefinition.Name}");
+                    if (_config.DryRun)
+                        continue;
+
+                    (var contents, var modelClassName) = CreateWorkflowClass(workflowDefinition);
+
+                    if (contents != null && !_config.DryRun)
+                    {
+                        var filePath = Path.Combine(workflowDirectory, $"{modelClassName}.scaff.cs");
+                        File.WriteAllText(filePath, contents);
+                    }
                 }
             }
 
-            var taskDefinitions = await _metadataService.GetAllTaskDefinitions();
-            var tasksDirectory = Path.Combine(_config.Destination, "Tasks");
-            Directory.CreateDirectory(tasksDirectory);
-            foreach (var taskDefinition in taskDefinitions)
+            if (!_config.IgnoreTasks)
             {
-                (var contents, var modelClassName) = CreateTaskClass(taskDefinition);
-
-                if (contents != null)
+                var taskDefinitions = await _metadataService.GetAllTaskDefinitions();
+                taskDefinitions = Filter(taskDefinitions, taskFilters).ToArray();
+                var tasksDirectory = Path.Combine(_config.Destination, "Tasks");
+                Directory.CreateDirectory(tasksDirectory);
+                foreach (var taskDefinition in taskDefinitions)
                 {
-                    var filePath = Path.Combine(tasksDirectory, $"{modelClassName}.scaff.cs");
-                    File.WriteAllText(filePath, contents);
+                    Console.WriteLine($"Scaffolding task {taskDefinition.Name}");
+                    if (_config.DryRun)
+                        continue;
+
+                    (var contents, var modelClassName) = CreateTaskClass(taskDefinition);
+
+                    if (contents != null)
+                    {
+                        var filePath = Path.Combine(tasksDirectory, $"{modelClassName}.scaff.cs");
+                        File.WriteAllText(filePath, contents);
+                    }
                 }
             }
         }
@@ -167,9 +187,6 @@ public async Task Scaffold()
             modelGenerator.AddXmlComment("ownerEmail", workflowDefinition.OwnerEmail);
             modelGenerator.AddXmlComment("note", note);
 
-            if (_config.Dryrun)
-                return (null, null);
-
             return (modelGenerator.Build(), name);
         }
 
@@ -235,10 +252,42 @@ private void DefinePropertyParams(TaskModelGenerator.PropertyData propData, stri
                 _logger.LogWarning($"No owner app defined for task {taskDefinition.Name}");
 
             modelGenerator.AddXmlComment("summary", description.Replace('\n', ','));
-            if (_config.Dryrun)
-                return (null, null);
 
             return (modelGenerator.Build(), name);
         }
+
+        private ITaskFilter[] CreateTaskFilters()
+        {
+            var taskFilters = new List<ITaskFilter>();
+            if (_config.NameFilters.Length != 0)
+                taskFilters.Add(new NameTaskFilter(_config.NameFilters));
+            if (_config.OwnerAppFilters.Length != 0)
+                taskFilters.Add(new OwnerAppTaskFilter(_config.OwnerAppFilters));
+            if (_config.OwnerEmailFilters.Length != 0)
+                taskFilters.Add(new OwnerEmailTaskFilter(_config.OwnerEmailFilters));
+
+            return taskFilters.ToArray();
+        }
+
+        private IWorkflowFilter[] CreateWorkflowFilters()
+        {
+            var workflowFilters = new List<IWorkflowFilter>();
+            if (_config.NameFilters.Length != 0)
+                workflowFilters.Add(new NameWorkflowFilter(_config.NameFilters));
+            if (_config.OwnerAppFilters.Length != 0)
+                workflowFilters.Add(new OwnerAppWorkflowFilter(_config.OwnerAppFilters));
+            if (_config.OwnerEmailFilters.Length != 0)
+                workflowFilters.Add(new OwnerEmailWorkflowFilter(_config.OwnerEmailFilters));
+
+            return workflowFilters.ToArray();
+        }
+
+        // If filter list is empty then all workflows/tasks are returned
+
+        private IEnumerable<WorkflowDefinition> Filter(IEnumerable<WorkflowDefinition> workflows, IWorkflowFilter[] filters) =>
+            workflows.Where(wf => filters.All(filter => filter.Test(wf)));
+
+        private IEnumerable<TaskDefinition> Filter(IEnumerable<TaskDefinition> tasks, ITaskFilter[] filters) =>
+            tasks.Where(task => filters.All(filter => filter.Test(task)));
     }
 }

src/ConductorSharp.Toolkit/Util/RegexUtil.cs

@@ -0,0 +1,9 @@
+using System.Text.RegularExpressions;
+
+namespace ConductorSharp.Toolkit.Util
+{
+    public static class RegexUtil
+    {
+        public static Regex CreateNameRegex(string name) => new($"^{Regex.Escape(name).Replace("%", ".*")}$", RegexOptions.Compiled);
+    }
+}