Added **RestJson** service automation.

Added **Integration** testing using MSTest.

Author: sgiffinlcd

src/Architecture/CodeFactory.Architecture.Blazor.Server/CodeFactory.Architecture.Blazor.Server.csproj

@@ -48,7 +48,20 @@
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="LoadExternalConfiguration.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RegisterTransientServices.cs" />
+    <Compile Include="ReloadAutomationConfiguration.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Automation\CodeFactory.Automation.NDF.Logic\CodeFactory.Automation.NDF.Logic.csproj">
+      <Project>{01f5417b-d33e-43ba-9d13-e9114eb989ac}</Project>
+      <Name>CodeFactory.Automation.NDF.Logic</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Automation\CodeFactory.Automation.Standard.Logic\CodeFactory.Automation.Standard.Logic.csproj">
+      <Project>{b1973f62-7951-41d3-a227-f3584b7f3cde}</Project>
+      <Name>CodeFactory.Automation.Standard.Logic</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

src/Architecture/CodeFactory.Architecture.Blazor.Server/LoadExternalConfiguration.cs

@@ -0,0 +1,78 @@
+using CodeFactory.WinVs;
+using CodeFactory.WinVs.Commands;
+using CodeFactory.WinVs.Commands.IDE;
+using CodeFactory.WinVs.Logging;
+using CodeFactory.WinVs.Models.CSharp;
+using CodeFactory.WinVs.Models.CSharp.Builder;
+using CodeFactory.WinVs.Models.ProjectSystem;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CodeFactory.Architecture.Blazor.Server
+{
+    /// <summary>
+    /// Code factory command that is executed when the solution is loaded. This command only gets called one time on load of the solution.
+    /// </summary>
+    public class LoadExternalConfiguration : SolutionLoadCommandBase
+    {
+        private static readonly string commandTitle = "Load External Configuration";
+        private static readonly string commandDescription = "Loads the external configuration for automation.";
+
+        #pragma warning disable CS1998
+        /// <inheritdoc />
+        public LoadExternalConfiguration(ILogger logger, IVsActions vsActions) : base(logger, vsActions, commandTitle, commandDescription)
+        {
+            //Intentionally blank
+        }
+
+        /// <summary>
+        /// Code factory framework calls this method when the command has been executed. 
+        /// </summary>
+        /// <param name="result">The code factory model that has generated and provided to the command to process.</param>
+        public override async Task ExecuteCommandAsync(VsSolution result)
+        {
+
+            try
+            {
+                //var addMissingMember = new AddMissingMembersNDF(null, null);
+                //addMissingMember.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                //var refreshEFRepository = new RefreshEFRepository(null, null);
+                //refreshEFRepository.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                //var refreshRestService = new RefreshRestService(null, null);
+                //refreshRestService.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                //var refreshTest = new RefreshTest(null, null);
+                //refreshTest.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                //var refreshFluentValidation = new RefreshFluentValidation(null, null);
+                //refreshFluentValidation.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                //var addMissingRepositoryMembers = new AddMissingRepositoryMembers(null, null);
+                //addMissingRepositoryMembers.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                //var updateLogicImplementation = new UpdateLogicImplementation(null, null);
+                //updateLogicImplementation.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                //var addMissingLogicMembers = new AddMissingLogicMembers(null, null); 
+                //addMissingLogicMembers.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                //var addMissingControllerMembers = new AddMissingControllerMembers(null, null);
+                //addMissingControllerMembers.LoadExternalConfigDefinition().RegisterCommandWithDefaultConfiguration();
+
+                ConfigManager.LoadConfiguration(result, "Automation", VisualStudioActions);
+            }
+            catch (Exception unhandledError)
+            {
+                _logger.Error($"The following unhandled error occurred while executing the solution explorer solution command {commandTitle}. ",
+                    unhandledError);
+
+            }
+
+        }
+    }
+}

src/Architecture/CodeFactory.Architecture.Blazor.Server/RegisterTransientServices.cs

@@ -0,0 +1,98 @@
+using CodeFactory.Automation.NDF.Logic;
+using CodeFactory.WinVs;
+using CodeFactory.WinVs.Commands;
+using CodeFactory.WinVs.Commands.SolutionExplorer;
+using CodeFactory.WinVs.Logging;
+using CodeFactory.WinVs.Models.CSharp;
+using CodeFactory.WinVs.Models.CSharp.Builder;
+using CodeFactory.WinVs.Models.ProjectSystem;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+
+namespace CodeFactory.Architecture.Blazor.Server
+{
+/// <summary>
+    /// Code factory command for automation of a project when selected from solution explorer.
+    /// </summary>
+    public class RegisterTransientServices : ProjectCommandBase
+    {
+        private static readonly string commandTitle = "Register Transient Services";
+        private static readonly string commandDescription = "Registers Transient classes with a NDF dependency injection loader for a target project.";
+
+#pragma warning disable CS1998
+
+        /// <inheritdoc />
+        public RegisterTransientServices(ILogger logger, IVsActions vsActions) : base(logger, vsActions, commandTitle, commandDescription)
+        {
+            //Intentionally blank
+        }
+#pragma warning disable CS1998
+
+        #region External Configuration
+
+        /// <summary>
+        /// The fully qualified name of the command to be used with configuration.
+        /// </summary>
+        public static string Type = typeof(RegisterTransientServices).FullName;
+
+        /// <summary>
+        /// Loads the external configuration definition for this command.
+        /// </summary>
+        /// <returns>Will return the command configuration or null if this command does not support external configurations.</returns>
+        public override ConfigCommand LoadExternalConfigDefinition()
+        {
+            return null;
+        }
+        #endregion
+
+        #region Overrides of VsCommandBase<VsProject>
+
+        /// <summary>
+        /// Validation logic that will determine if this command should be enabled for execution.
+        /// </summary>
+        /// <param name="result">The target model data that will be used to determine if this command should be enabled.</param>
+        /// <returns>Boolean flag that will tell code factory to enable this command or disable it.</returns>
+        public override async Task<bool> EnableCommandAsync(VsProject result)
+        {
+            //Result that determines if the command is enabled and visible in the context menu for execution.
+            bool isEnabled = false;
+
+            try
+            {
+                isEnabled = await result.CanRegisterTransientClassesAsync();
+            }
+            catch (Exception unhandledError)
+            {
+                _logger.Error($"The following unhandled error occurred while checking if the solution explorer project command {commandTitle} is enabled. ",
+                    unhandledError);
+                isEnabled = false;
+            }
+
+            return isEnabled;
+        }
+
+        /// <summary>
+        /// Code factory framework calls this method when the command has been executed. 
+        /// </summary>
+        /// <param name="result">The code factory model that has generated and provided to the command to process.</param>
+        public override async Task ExecuteCommandAsync(VsProject result)
+        {
+            try
+            {
+                await VisualStudioActions.RegisterTransientClassesAsync(result);
+            }
+            catch (Exception unhandledError)
+            {
+                _logger.Error($"The following unhandled error occurred while executing the solution explorer project command {commandTitle}. ",
+                    unhandledError);
+
+            }
+        }
+
+        #endregion
+    }
+}

src/Architecture/CodeFactory.Architecture.Blazor.Server/ReloadAutomationConfiguration.cs

@@ -0,0 +1,96 @@
+using CodeFactory.WinVs;
+using CodeFactory.WinVs.Commands;
+using CodeFactory.WinVs.Commands.SolutionExplorer;
+using CodeFactory.WinVs.Logging;
+using CodeFactory.WinVs.Models.CSharp;
+using CodeFactory.WinVs.Models.CSharp.Builder;
+using CodeFactory.WinVs.Models.ProjectSystem;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CodeFactory.Architecture.Blazor.Server
+{
+/// <summary>
+    /// Code factory command for automation of the solution when selected from solution explorer.
+    /// </summary>
+    public class ReloadAutomationConfiguration : SolutionCommandBase
+    {
+        private static readonly string commandTitle = "Reload Automation Configuration";
+        private static readonly string commandDescription = "Reloads the automation configuration.";
+
+#pragma warning disable CS1998
+        /// <inheritdoc />
+        public ReloadAutomationConfiguration(ILogger logger, IVsActions vsActions) : base(logger, vsActions, commandTitle, commandDescription)
+        {
+            //Intentionally blank
+        }
+
+        #region External Configuration
+
+        /// <summary>
+        /// The fully qualified name of the command to be used with configuration.
+        /// </summary>
+        public static string Type = typeof(ReloadAutomationConfiguration).FullName;
+
+        /// <summary>
+        /// Loads the external configuration definition for this command.
+        /// </summary>
+        /// <returns>Will return the command configuration or null if this command does not support external configurations.</returns>
+        public override ConfigCommand LoadExternalConfigDefinition()
+        {
+            return null;
+        }
+        #endregion
+
+        #region Overrides of VsCommandBase<VsSolution>
+
+        /// <summary>
+        /// Validation logic that will determine if this command should be enabled for execution.
+        /// </summary>
+        /// <param name="result">The target model data that will be used to determine if this command should be enabled.</param>
+        /// <returns>Boolean flag that will tell code factory to enable this command or disable it.</returns>
+        public override async Task<bool> EnableCommandAsync(VsSolution result)
+        {
+            //Result that determines if the command is enabled and visible in the context menu for execution.
+            bool isEnabled = false;
+
+            try
+            {
+                isEnabled = await ConfigManager.HasAutomationConfigAsync(result, "Automation");
+            }
+            catch (Exception unhandledError)
+            {
+                _logger.Error($"The following unhandled error occurred while checking if the solution explorer solution command {commandTitle} is enabled. ",
+                    unhandledError);
+                isEnabled = false;
+            }
+
+            return isEnabled;
+        }
+
+        /// <summary>
+        /// Code factory framework calls this method when the command has been executed. 
+        /// </summary>
+        /// <param name="result">The code factory model that has generated and provided to the command to process.</param>
+        public override async Task ExecuteCommandAsync(VsSolution result)
+        {
+
+            try
+            {
+                ConfigManager.LoadConfiguration(result, "Automation", VisualStudioActions);
+            }
+            catch (Exception unhandledError)
+            {
+                _logger.Error($"The following unhandled error occurred while executing the solution explorer solution command {commandTitle}. ",
+                    unhandledError);
+
+            }
+
+        }
+
+        #endregion
+    }
+}

src/Automation/CodeFactory.Automation.NDF.Logic/AspNetCore/Service/Rest/Json/MethodExtensions.cs

@@ -0,0 +1,78 @@
+using CodeFactory.WinVs.Models.CSharp;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CodeFactory.Automation.NDF.Logic.AspNetCore.Service.Rest.Json
+{
+/// <summary>
+    /// Method extensions that support name generation for rest services.
+    /// </summary>
+    public static class MethodExtensions
+    {
+        /// <summary>
+        /// Generates the rest action name based on the method name and the supporting parameters of the method.
+        /// </summary>
+        /// <param name="source">The source method to extract the name from.</param>
+        /// <param name="fullSignatureName">Flag that determines if the parameters of the method should also be used in the name rest call.</param>
+        /// <returns>The formatted name of the rest call.</returns>
+        /// <exception cref="CodeFactoryException">Raised if required data is missing.</exception>
+        public static string GetRestName(this CsMethod source, bool fullSignatureName = false)
+        {
+            if (source == null)
+                throw new CodeFactoryException(
+                    "Cannot update the rest service, a method was not provided so cannot determine the name of the rest call.");
+
+            if (string.IsNullOrEmpty(source.Name))
+                throw new CodeFactoryException(
+                    "Cannot update the rest service, the method name was empty or null, cannot determine the name of the rest call.");
+
+
+            StringBuilder restNameBuilder = new StringBuilder();
+
+            var methodName = source.Name.Trim();
+
+            restNameBuilder.Append(methodName.EndsWith("Async", StringComparison.InvariantCultureIgnoreCase)
+                ? methodName.Substring(0, methodName.Length - 5)
+                : methodName);
+
+            if (!(fullSignatureName & source.HasParameters)) return restNameBuilder.ToString();
+
+            restNameBuilder.Append("By");
+
+            bool firstParameter = true;
+            foreach (var sourceParameter in source.Parameters)
+            {
+                if (string.IsNullOrEmpty(sourceParameter.Name)) continue;
+
+                if (firstParameter)
+                {
+                    restNameBuilder.Append(sourceParameter.Name.ToUpper().First());
+                    firstParameter = false;
+                }
+                else
+                {
+                    restNameBuilder.Append(sourceParameter.Name.ToLower().First());
+                }
+            }
+
+            return restNameBuilder.ToString();
+        }
+
+        /// <summary>
+        /// Determines of the source method will be called as a post call or not. 
+        /// </summary>
+        /// <param name="source">Target method to check for a post call.</param>
+        /// <returns>True if the call will be post based or false if not.</returns>
+        /// <exception cref="CodeFactoryException">Raised if required data is missing.</exception>
+        public static bool IsPostCall(this CsMethod source)
+        {
+            if (source == null)
+                throw new CodeFactoryException("No method was provided cannot determine if a Post call.");
+
+            return source.HasParameters;
+        }
+    }
+}