Implemented a controller name convention

A statemachine meta controller is now paired with the subjec type,
and when configuring the state machine feature, we can set a controller name with which we configure the meta controller routes

Author: Csernák Tamás

common/common.utils/StateMachineFeature/StateMachineController.cs

@@ -5,7 +5,7 @@
 namespace CST.Common.Utils.StateMachineFeature
 {
     [Controller]
-    public class StateMachineController<TKey> : ControllerBase 
+    public class StateMachineController<TKey, TSubject> : ControllerBase 
         where TKey : struct, IEquatable<TKey>
     {
         private readonly IStateMachineMetaService<TKey> _stateMachineMetaService;
@@ -22,15 +22,11 @@ public IActionResult GetStates()
         }
 
         [HttpGet("transitions")]
-        public IActionResult GetTransitions()
+        public IActionResult GetTransitions([FromQuery] TKey? currentStateId)
         {
-            return Ok(_stateMachineMetaService.GetInitialTransitions());
-        }
-
-        [HttpGet("transitions/{currentStateId}")]
-        public IActionResult GetTransitions(TKey currentStateId)
-        {
-            return Ok(_stateMachineMetaService.GetTransitions(currentStateId));
+            return Ok(currentStateId.HasValue 
+                ? _stateMachineMetaService.GetTransitions(currentStateId.Value) 
+                : _stateMachineMetaService.GetInitialTransitions());
         }
     }
 }

common/common.utils/StateMachineFeature/StateMachineControllerNameConvention.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ApplicationModels;
+
+namespace CST.Common.Utils.StateMachineFeature
+{
+    public class StateMachineControllerNameConvention<TKey, TSubject> : IControllerModelConvention
+        where TKey : struct, IEquatable<TKey>
+    {
+        private readonly string _controllerName;
+
+        public StateMachineControllerNameConvention(string controllerName)
+        {
+            _controllerName = controllerName;
+        }
+        public void Apply(ControllerModel controller)
+        {
+            if (controller.ControllerType != typeof(StateMachineController<TKey, TSubject>)) return;
+
+            controller.Selectors.Clear();
+            controller.Selectors.Add(new SelectorModel
+            {
+                AttributeRouteModel = new AttributeRouteModel(new RouteAttribute($"/api/{_controllerName}"))
+            });
+        }
+    }
+}

common/common.utils/StateMachineFeature/StateMachineFeatureBuilder.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Runtime.InteropServices.ComTypes;
 using CST.Common.Utils.StateMachineFeature.BaseClasses;
 using CST.Common.Utils.StateMachineFeature.ViewModel;
 using Microsoft.AspNetCore.Mvc.ApplicationParts;
@@ -9,154 +10,114 @@ namespace CST.Common.Utils.StateMachineFeature
 {
     public class StateMachineFeatureBuilder
     {
-        private readonly IList<IApplicationFeatureProvider> _featureProviders;
-        private readonly IServiceCollection _services;
+        protected readonly IMvcCoreBuilder MvcCoreBuilder;
+        protected readonly IServiceCollection Services;
 
         public StateMachineFeatureBuilder(IServiceCollection services)
         {
-            _featureProviders = services.AddMvcCore().PartManager.FeatureProviders;
-            _services = services;
+            MvcCoreBuilder = services.AddMvcCore();
+            Services = services;
         }
 
         public StateMachineFeatureBuilder<T> WithKeyType<T>()
             where T : struct, IEquatable<T>
         {
-            return new StateMachineFeatureBuilder<T>(_featureProviders, _services);
+            return new StateMachineFeatureBuilder<T>(Services);
         }
     }
 
-    public class StateMachineFeatureBuilder<T1>
+    public class StateMachineFeatureBuilder<T1> : StateMachineFeatureBuilder
         where T1 : struct, IEquatable<T1>
     {
-        private readonly IList<IApplicationFeatureProvider> _featureProviders;
-        private readonly IServiceCollection _services;
-
-        public StateMachineFeatureBuilder(
-            IList<IApplicationFeatureProvider> featureProviders,
-            IServiceCollection services)
+        public StateMachineFeatureBuilder(IServiceCollection services) : base(services)
         {
-            _featureProviders = featureProviders;
-            _services = services;
         }
 
         public StateMachineFeatureBuilder<T1, T> WithGraphEnumType<T>()
             where T : struct, IConvertible
         {
-            return new StateMachineFeatureBuilder<T1, T>(_featureProviders, _services);
+            return new StateMachineFeatureBuilder<T1, T>(Services);
         }
     }
 
-    public class StateMachineFeatureBuilder<T1, T2>
+    public class StateMachineFeatureBuilder<T1, T2> : StateMachineFeatureBuilder<T1>
         where T1 : struct, IEquatable<T1>
         where T2 : struct, IConvertible
     {
-        private readonly IList<IApplicationFeatureProvider> _featureProviders;
-        private readonly IServiceCollection _services;
-
-        public StateMachineFeatureBuilder(
-            IList<IApplicationFeatureProvider> featureProviders,
-            IServiceCollection services)
+        public StateMachineFeatureBuilder(IServiceCollection services) : base(services)
         {
-            _featureProviders = featureProviders;
-            _services = services;
         }
 
         public StateMachineFeatureBuilder<T1, T2, T> WithVertexEnumType<T>()
             where T : struct, IConvertible
         {
-            return new StateMachineFeatureBuilder<T1, T2, T>(_featureProviders, _services);
+            return new StateMachineFeatureBuilder<T1, T2, T>(Services);
         }
     }
 
-    public class StateMachineFeatureBuilder<T1, T2, T3>
+    public class StateMachineFeatureBuilder<T1, T2, T3> : StateMachineFeatureBuilder<T1, T2>
         where T1 : struct, IEquatable<T1>
         where T2 : struct, IConvertible
         where T3 : struct, IConvertible
     {
-        private readonly IList<IApplicationFeatureProvider> _featureProviders;
-        private readonly IServiceCollection _services;
-
-        public StateMachineFeatureBuilder(
-            IList<IApplicationFeatureProvider> featureProviders,
-            IServiceCollection services)
+        public StateMachineFeatureBuilder(IServiceCollection services) : base(services)
         {
-            _featureProviders = featureProviders;
-            _services = services;
         }
 
-        public StateMachineFeatureBuilder<T1, T2, T3, T> WithSubjectType<T>()
+        public StateMachineFeatureBuilder<T1, T2, T3, T> WithSubjectType<T>(string controllerName)
             where T : StateMachineSubject<T1, T2, T3, T>, new()
         {
-            return new StateMachineFeatureBuilder<T1, T2, T3, T>(_featureProviders, _services);
+            return new StateMachineFeatureBuilder<T1, T2, T3, T>(Services, controllerName);
         }
     }
 
-    public class StateMachineFeatureBuilder<T1, T2, T3, T4>
+    public class StateMachineFeatureBuilder<T1, T2, T3, T4> : StateMachineFeatureBuilder<T1, T2, T3>
         where T1 : struct, IEquatable<T1>
         where T2 : struct, IConvertible
         where T3 : struct, IConvertible
         where T4 : StateMachineSubject<T1, T2, T3, T4>, new()
     {
-        private readonly IList<IApplicationFeatureProvider> _featureProviders;
-        private readonly IServiceCollection _services;
-
-        public StateMachineFeatureBuilder(
-            IList<IApplicationFeatureProvider> featureProviders,
-            IServiceCollection services)
+        protected readonly string SubjectControllerName;
+        public StateMachineFeatureBuilder(IServiceCollection services, string subjectControllerName) : base(services)
         {
-            _featureProviders = featureProviders;
-            _services = services;
+            SubjectControllerName = subjectControllerName;
         }
 
         public StateMachineFeatureBuilder<T1, T2, T3, T4, T> WithRepositoryType<T>()
             where T : BaseStateMachineRepository<T1, T2, T3, T4>
         {
-            return new StateMachineFeatureBuilder<T1, T2, T3, T4, T>(_featureProviders, _services);
+            return new StateMachineFeatureBuilder<T1, T2, T3, T4, T>(Services, SubjectControllerName);
         }
     }
 
-    public class StateMachineFeatureBuilder<T1, T2, T3, T4, T5>
+    public class StateMachineFeatureBuilder<T1, T2, T3, T4, T5> : StateMachineFeatureBuilder<T1, T2, T3, T4>
         where T1 : struct, IEquatable<T1>
         where T2 : struct, IConvertible
         where T3 : struct, IConvertible
         where T4 : StateMachineSubject<T1, T2, T3, T4>, new()
         where T5 : BaseStateMachineRepository<T1, T2, T3, T4>
     {
-        private readonly IList<IApplicationFeatureProvider> _featureProviders;
-        private readonly IServiceCollection _services;
-
-        public StateMachineFeatureBuilder(
-            IList<IApplicationFeatureProvider> featureProviders,
-            IServiceCollection services)
+        public StateMachineFeatureBuilder(IServiceCollection services, string subjectControllerName) : base(services, subjectControllerName)
         {
-            _featureProviders = featureProviders;
-            _services = services;
         }
 
         public StateMachineFeatureBuilder<T1, T2, T3, T4, T5, T> WithStateMachineService<T>()
             where T : BaseStateMachineService<T1, T2, T3, T4, T5>
         {
-            return new StateMachineFeatureBuilder<T1, T2, T3, T4, T5, T>(_featureProviders, _services);
+            return new StateMachineFeatureBuilder<T1, T2, T3, T4, T5, T>(Services, SubjectControllerName);
         }
     }
 
-    public class StateMachineFeatureBuilder<T1, T2, T3, T4, T5, T6>
+    public class StateMachineFeatureBuilder<T1, T2, T3, T4, T5, T6> : StateMachineFeatureBuilder<T1, T2, T3, T4, T5>
         where T1 : struct, IEquatable<T1>
         where T2 : struct, IConvertible
         where T3 : struct, IConvertible
         where T4 : StateMachineSubject<T1, T2, T3, T4>, new()
         where T5 : BaseStateMachineRepository<T1, T2, T3, T4>
         where T6 : BaseStateMachineService<T1, T2, T3, T4, T5>
     {
-        private readonly IList<IApplicationFeatureProvider> _featureProviders;
-        private readonly IServiceCollection _services;
-
-        public StateMachineFeatureBuilder(
-            IList<IApplicationFeatureProvider> featureProviders,
-            IServiceCollection services)
+        public StateMachineFeatureBuilder(IServiceCollection services, string subjectControllerName) : base(services, subjectControllerName)
         {
-            _featureProviders = featureProviders;
-            _services = services;
         }
 
         public void Build()
@@ -169,24 +130,28 @@ public void Build()
 
         private void AddFeatureProvider()
         {
-            _featureProviders.Add(new StateMachineFeatureProvider<T1>());
+            MvcCoreBuilder.PartManager.FeatureProviders.Add(new StateMachineFeatureProvider<T1, T4>());
         }
 
         private void AddStateMachineRepository()
         {
-            _services.AddScoped<T5>();
-            _services.AddScoped<BaseStateMachineRepository<T1, T2, T3, T4>>((svc) => svc.GetService<T5>());
+            Services.AddScoped<T5>();
+            Services.AddScoped<BaseStateMachineRepository<T1, T2, T3, T4>>((svc) => svc.GetService<T5>());
         }
 
         private void AddStateMachineMetaService()
         {
-            _services.AddScoped<IStateMachineMetaService<T1>, StateMachineMetaService<T1, T2, T3, T5, T4>>();
+            Services.AddScoped<IStateMachineMetaService<T1>, StateMachineMetaService<T1, T2, T3, T5, T4>>();
+            MvcCoreBuilder.AddMvcOptions(o =>
+                {
+                    o.Conventions.Add(new StateMachineControllerNameConvention<T1, T4>(SubjectControllerName));
+                });
         }
 
         private void AddStateMachineService()
         {
-            _services.AddScoped<T6>();
-            _services.AddScoped<BaseStateMachineService<T1, T2, T3, T4, T5>>(
+            Services.AddScoped<T6>();
+            Services.AddScoped<BaseStateMachineService<T1, T2, T3, T4, T5>>(
                 serviceProvider => serviceProvider.GetRequiredService<T6>());
         }
     }

common/common.utils/StateMachineFeature/StateMachineFeatureProvider.cs

@@ -6,12 +6,12 @@
 
 namespace CST.Common.Utils.StateMachineFeature
 {
-    internal class StateMachineFeatureProvider<TKey> : IApplicationFeatureProvider<ControllerFeature> 
+    internal class StateMachineFeatureProvider<TKey, TSubject> : IApplicationFeatureProvider<ControllerFeature> 
         where TKey : struct, IEquatable<TKey>
     {
         public void PopulateFeature(IEnumerable<ApplicationPart> parts, ControllerFeature feature)
         {
-            feature.Controllers.Add(typeof(StateMachineController<TKey>).GetTypeInfo());
+            feature.Controllers.Add(typeof(StateMachineController<TKey, TSubject>).GetTypeInfo());
         }
     }
 }