Add Base controller class for Rest services. (#992)

* Add Base controller class for Rest services.

* Temporary disable sending server name.CodeQL cs/user-controlled-bypass

* Move GxRestService from GxClasses to GxClasses.Web

* Return a StatusCode for WebException

* Add method SendNotModified

* Register native services at startup when SERVICE_AS_CONTROLLER is enabled.

* Avoid setting headers when request has started.
Add [JsonIgnore] to non-json serializable properties

* Fix build error.

* Add Json annotations for Message SDT

* Fix registration of API services in modules.

* Temporary cleanup of duplicated REST services: remove REST controllers loaded from API assemblies

* Set BasePath for rest services

* Add ApiException method to handle unexpected exceptions properly in declarative rest services.

* Handle status code set by user code.

* Handle GAMErrors property in declared rest services.

* Add method ApiIntegratedSecurityLevel to base Rest class.

* Improve error handling in rest controllers.

* Do not set statuscode if it is 0 (non initialized)

* Remove CustomControllerFeatureProvider as it is no longer needed.
Rest service controllers now exist in a single assembly.

* Avoid processing .grp.json when services as controllers are enabled.

* Handle BadRequest when json input is invalid.
Return custom error instead of:
{
    "type": "....",
    "title": "One or more validation errors occurred.",
    "status": 400,
    "errors": {
        "$.VarCond": [
            "The JSON value could not be converted to System.Int16. Path: $.VarCond | LineNumber: 0 | BytePositionInLine: 16."
        ]
    },
    "traceId": "....
}

* Add IsAnyDirty for SDTs

* Define IsNull method for rest interfaces

* Add missing JsonIgnore flags.

* Add method EmptyResponse to return a valid empty json instead of empty body.

* Add AnyDirtySdt method.

* Add NullResult function.

* Remove unneeded AnyDirtySdt property.
SDT and collection properties on SDTS are marked as dirty on get method also.

* Add EmptyObjectResult

* Property's name must use a case-insensitive comparison during json deserialization

* Grouped several lines of code into a new function, RegisterControllerAssemblies.

* Updated JsonSerializerOptions.PropertyNameCaseInsensitive to be controlled by the ServiceJsonSerializerCaseSensitive configuration property

* Change key ServiceJsonSerializerCaseSensitive for a shorter one: RestJsonCaseSensitive.

* Remove unnecessary AddControllers() call as the current assembly has no controllers

* Ensure that controllers from the specified assembly are registered as services and can have their dependencies injected.

* Support UploadImpl for controller rest services.

* SERVICE_AS_CONTROLLER is turned on by default now.

* SERVICE_AS_CONTROLLER is now enabled by default. Tests relying on the previous default behavior must explicitly set it to off.

* HttpContext was null at rest services.

* Map NullReference Exception as BadRequest Error.
P.e when executing Issue89123_API/Check with an invalid json body
{
"ClientId": 1,
"ClientName": "CName",
"ClientActive": false
}

the issue89123_api_check_RequestData entity is created but entity.Issue89123Client is null.

* Try to fix failing test for DotNetCore.
Failed UnitTesting.FileIOTests.GXDBFilePathTest
System.UriFormatException : Invalid URI: The format of the URI could not be determined.

* Generate rest controllers as HTTP Azure functions at deploy time for Azure Functions deployment

* Add BoolStringJsonConverter for Boolean properties in Stds.

* Update ErrorCheck to return the JSON response object.

* Try to fix merge error.

* Remove unnecessary SetError method and replace it with HandleError

* Create a GetErrorResponse for HandleError and for ErrorCheck

* Add tracing to help identify the root cause of the failing test

* Temporarily disable the test on Linux while investigating the issue

* Replace HttpHelper.SetError with HandleError to assign _errorDetail (returned by Unauthenticated)

* Add missing ApiIntegratedSecurityLevel method for .NETFramework.

---------

Co-authored-by: Claudia Beatriz Murialdo Garrone <c.murialdo@globant.com>
Co-authored-by: sjuarez <sabrina.juarez@globant.com>

Author: 3 people

dotnet/src/dotnetcore/GxClasses.Web/Middleware/GXRestServices.cs

@@ -38,7 +38,7 @@ internal class GXRouting : IGXRouting
 		public static string UrlTemplateControllerWithParms;
 
 		//Azure Functions
-		public bool AzureRuntime;
+		public static bool AzureRuntime;
 		public AzureDeployFeature AzureDeploy = new AzureDeployFeature();
 		public static string AzureFunctionName;
 
@@ -382,7 +382,7 @@ public bool ServiceInPath(String path, out String actualPath)
 		private String FindPath(string innerPath, Dictionary<string,string > servicesPathUrl, bool startTxt)
 		{
 			string actualPath = String.Empty;
-			foreach (var subPath in from String subPath in servicesPathUrl.Keys									
+			foreach (string subPath in from String subPath in servicesPathUrl.Keys									
 									select subPath)
 			{
 				bool match = false;
@@ -525,48 +525,51 @@ public void ServicesGroupSetting()
 								string mapPathLower = mapPath.ToLower();
 								string mNameLower = m.Name.ToLower();
 								servicesPathUrl[mapPathLower]= mNameLower;
-								GXLogging.Debug(log, $"addServicesPathUrl key:{mapPathLower} value:{mNameLower}");
-								foreach (SingleMap sm in m.Mappings)
+								if (!RestAPIHelpers.ServiceAsController())
 								{
-									if (sm.Verb == null)
-										sm.Verb = "GET";
-									if (String.IsNullOrEmpty(sm.Path))
-										sm.Path = sm.Name;
-									else
+									GXLogging.Debug(log, $"addServicesPathUrl key:{mapPathLower} value:{mNameLower}");
+									foreach (SingleMap sm in m.Mappings)
 									{
-										sm.Path = Regex.Replace(sm.Path, "^/|/$", "");
-									}
-									if (sm.VariableAlias == null)
-										sm.VariableAlias = new Dictionary<string, string>();
-									else
-									{
-										Dictionary<string, string> vMap = new Dictionary<string, string>();
-										foreach (KeyValuePair<string, string> v in sm.VariableAlias)
+										if (sm.Verb == null)
+											sm.Verb = "GET";
+										if (String.IsNullOrEmpty(sm.Path))
+											sm.Path = sm.Name;
+										else
 										{
-											vMap.Add(v.Key.ToLower(), v.Value.ToLower());
+											sm.Path = Regex.Replace(sm.Path, "^/|/$", "");
 										}
-										sm.VariableAlias = vMap;
-									}
-									if (servicesMap.ContainsKey(mapPathLower))
-									{
-										if (!servicesMap[mapPathLower].ContainsKey(sm.Name.ToLower()))
+										if (sm.VariableAlias == null)
+											sm.VariableAlias = new Dictionary<string, string>();
+										else
+										{
+											Dictionary<string, string> vMap = new Dictionary<string, string>();
+											foreach (KeyValuePair<string, string> v in sm.VariableAlias)
+											{
+												vMap.Add(v.Key.ToLower(), v.Value.ToLower());
+											}
+											sm.VariableAlias = vMap;
+										}
+										if (servicesMap.ContainsKey(mapPathLower))
 										{
+											if (!servicesMap[mapPathLower].ContainsKey(sm.Name.ToLower()))
+											{
+												servicesValidPath[mapPathLower].Add(sm.Path.ToLower());
+
+												servicesMapData[mapPathLower].Add(Tuple.Create(sm.Path.ToLower(), sm.Verb.ToUpper()), sm.Name.ToLower());
+												servicesMap[mapPathLower].Add(sm.Name.ToLower(), sm);
+											}
+										}
+										else
+										{
+											servicesValidPath.Add(mapPathLower, new List<string>());
 											servicesValidPath[mapPathLower].Add(sm.Path.ToLower());
 
+											servicesMapData.Add(mapPathLower, new Dictionary<Tuple<string, string>, string>());
 											servicesMapData[mapPathLower].Add(Tuple.Create(sm.Path.ToLower(), sm.Verb.ToUpper()), sm.Name.ToLower());
+											servicesMap.Add(mapPathLower, new Dictionary<string, SingleMap>());
 											servicesMap[mapPathLower].Add(sm.Name.ToLower(), sm);
 										}
 									}
-									else
-									{
-										servicesValidPath.Add(mapPathLower, new List<string>());
-										servicesValidPath[mapPathLower].Add(sm.Path.ToLower());
-
-										servicesMapData.Add(mapPathLower, new Dictionary<Tuple<string, string>, string>());
-										servicesMapData[mapPathLower].Add(Tuple.Create(sm.Path.ToLower(), sm.Verb.ToUpper()), sm.Name.ToLower());
-										servicesMap.Add(mapPathLower, new Dictionary<string, SingleMap>());
-										servicesMap[mapPathLower].Add(sm.Name.ToLower(), sm);
-									}
 								}
 							}
 						}

dotnet/src/dotnetcore/GxClasses.Web/Middleware/GXRouting.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Net;
 using System.Reflection;
 using System.Threading.Tasks;
@@ -19,8 +20,9 @@
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
-using Microsoft.AspNetCore.HttpOverrides;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.ApplicationModels;
+using Microsoft.AspNetCore.Mvc.Routing;
 using Microsoft.AspNetCore.Rewrite;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
@@ -120,7 +122,15 @@ public static IApplicationBuilder MapWebSocketManager(this IApplicationBuilder a
 					.Map($"{basePath}/gxwebsocket.svc", (_app) => _app.UseMiddleware<Notifications.WebSocket.WebSocketManagerMiddleware>()); //Compatibility reasons. Remove in the future.
 		}
 	}
-  
+	public class CustomBadRequestObjectResult : ObjectResult
+	{
+		public CustomBadRequestObjectResult(ActionContext context)
+			: base(HttpHelper.GetJsonError(StatusCodes.Status400BadRequest.ToString(), HttpHelper.StatusCodeToTitle(HttpStatusCode.BadRequest)))
+		{
+			StatusCode = StatusCodes.Status400BadRequest;
+		}
+	}
+
 	public class Startup
 	{
 		static IGXLogger log;
@@ -163,24 +173,10 @@ public void ConfigureServices(IServiceCollection services)
 		{
 			OpenTelemetryService.Setup(services);
 
-			services.AddControllers();
-			string controllers = Path.Combine(Startup.LocalPath, "bin", GX_CONTROLLERS);
-			IMvcBuilder mvcBuilder = services.AddMvc(option => option.EnableEndpointRouting = false);
-			try
-			{
-				if (Directory.Exists(controllers))
-				{
-					foreach (string controller in Directory.GetFiles(controllers))
-					{
-						Console.WriteLine($"Loading controller {controller}");
-						mvcBuilder.AddApplicationPart(Assembly.LoadFrom(controller)).AddControllersAsServices();
-					}
-				}
-			}
-			catch (Exception ex)
-			{
-				Console.Error.WriteLine("Error loading gxcontrollers " + ex.Message);
-			}
+			IMvcBuilder builder = services.AddMvc(option => option.EnableEndpointRouting = false);
+	
+			RegisterControllerAssemblies(builder);
+
 			services.Configure<KestrelServerOptions>(options =>
 			{
 				options.AllowSynchronousIO = true;
@@ -269,6 +265,113 @@ public void ConfigureServices(IServiceCollection services)
 			DefineCorsPolicy(services);
 		}
 
+		private void RegisterControllerAssemblies(IMvcBuilder mvcBuilder)
+		{
+			
+			if (RestAPIHelpers.ServiceAsController() && !string.IsNullOrEmpty(VirtualPath))
+			{
+				mvcBuilder.AddMvcOptions(options =>	options.Conventions.Add(new SetRoutePrefix(new RouteAttribute(VirtualPath))));
+			}
+
+			if (RestAPIHelpers.JsonSerializerCaseSensitive())
+			{
+				mvcBuilder.AddJsonOptions(options => options.JsonSerializerOptions.PropertyNameCaseInsensitive = false);
+			}
+			mvcBuilder.ConfigureApiBehaviorOptions(options =>
+			{
+				options.InvalidModelStateResponseFactory = context =>
+				{
+					return new CustomBadRequestObjectResult(context);
+				};
+			});
+
+			if (RestAPIHelpers.ServiceAsController())
+			{
+				RegisterRestServices(mvcBuilder);
+				RegisterApiServices(mvcBuilder, gxRouting);
+			}
+			RegisterNativeServices(mvcBuilder);
+
+		}
+
+		private void RegisterNativeServices(IMvcBuilder mvcBuilder)
+		{
+			try
+			{
+				string controllers = Path.Combine(Startup.LocalPath, "bin", GX_CONTROLLERS);
+
+				if (Directory.Exists(controllers))
+				{
+					foreach (string controller in Directory.GetFiles(controllers))
+					{
+						Console.WriteLine($"Loading controller {controller}");
+						mvcBuilder.AddApplicationPart(Assembly.LoadFrom(controller)).AddControllersAsServices();
+					}
+				}
+			}
+			catch (Exception ex)
+			{
+				Console.Error.WriteLine("Error loading gxcontrollers " + ex.Message);
+			}
+
+		}
+
+		private void RegisterRestServices(IMvcBuilder mvcBuilder)
+		{
+			HashSet<string> serviceAssemblies = new HashSet<string>();
+			foreach (string svcFile in gxRouting.svcFiles)
+			{
+				try
+				{
+					string[] controllerAssemblyQualifiedName = new string(File.ReadLines(svcFile).First().SkipWhile(c => c != '"')
+															   .Skip(1)
+															   .TakeWhile(c => c != '"')
+															   .ToArray()).Trim().Split(',');
+					string controllerAssemblyName = controllerAssemblyQualifiedName.Last();
+					if (!serviceAssemblies.Contains(controllerAssemblyName))
+					{
+						serviceAssemblies.Add(controllerAssemblyName);
+						string controllerAssemblyFile = Path.Combine(Startup.LocalPath, "bin", $"{controllerAssemblyName}.dll");
+
+						if (File.Exists(controllerAssemblyFile))
+						{
+							GXLogging.Info(log, "Registering rest: " + controllerAssemblyName);
+							mvcBuilder.AddApplicationPart(Assembly.LoadFrom(controllerAssemblyFile)).AddControllersAsServices();
+						}
+					}
+				}
+				catch (Exception ex)
+				{
+					GXLogging.Error(log, "Error registering rest service", ex);
+				}
+			}
+		}
+		private void RegisterApiServices(IMvcBuilder mvcBuilder, GXRouting gxRouting)
+		{
+			HashSet<string> serviceAssemblies = new HashSet<string>();
+			foreach (string grp in gxRouting.servicesPathUrl.Values)
+			{
+				try
+				{
+					string assemblyName = grp.Replace('\\', '.');
+					if (!serviceAssemblies.Contains(assemblyName))
+					{
+						serviceAssemblies.Add(assemblyName);
+						string controllerAssemblyFile = Path.Combine(Startup.LocalPath, "bin", $"{assemblyName}.dll");
+						if (File.Exists(controllerAssemblyFile))
+						{
+							GXLogging.Info(log, "Registering api: " + grp);
+							mvcBuilder.AddApplicationPart(Assembly.LoadFrom(controllerAssemblyFile)).AddControllersAsServices();
+						}
+					}
+				}
+				catch (Exception ex)
+				{
+					GXLogging.Error(log, "Error registering api", ex);
+				}
+			}
+		}
+
 		private void DefineCorsPolicy(IServiceCollection services)
 		{
 			if (Preferences.CorsEnabled)
@@ -431,10 +534,6 @@ public void Configure(IApplicationBuilder app, Microsoft.AspNetCore.Hosting.IHos
 				ContentTypeProvider = provider
 			});
 
-			foreach( string p in gxRouting.servicesPathUrl.Keys)
-			{
-				 servicesBase.Add( string.IsNullOrEmpty(VirtualPath) ? p : $"{VirtualPath}/{p}");
-			}
 			app.UseExceptionHandler(new ExceptionHandlerOptions
 			{
 				ExceptionHandler = new CustomExceptionHandlerMiddleware().Invoke,
@@ -449,21 +548,31 @@ public void Configure(IApplicationBuilder app, Microsoft.AspNetCore.Hosting.IHos
 				antiforgery = app.ApplicationServices.GetRequiredService<IAntiforgery>();
 				app.UseAntiforgeryTokens(apiBasePath);
 			}
-			app.UseMvc(routes =>
+			if (!RestAPIHelpers.ServiceAsController())
 			{
-				foreach (string serviceBasePath in servicesBase)
-				{			
-					string tmpPath = string.IsNullOrEmpty(apiBasePath) ? serviceBasePath : serviceBasePath.Replace(apiBasePath, string.Empty);
-					foreach (string sPath in gxRouting.servicesValidPath[tmpPath])
+				foreach (string p in gxRouting.servicesPathUrl.Keys)
+				{
+					servicesBase.Add(string.IsNullOrEmpty(VirtualPath) ? p : $"{VirtualPath}/{p}");
+				}
+				app.UseMvc(routes =>
+				{
+					foreach (string serviceBasePath in servicesBase)
 					{
-						string s = serviceBasePath + sPath;
-						routes.MapRoute($"{s}", new RequestDelegate(gxRouting.ProcessRestRequest));
+						string tmpPath = string.IsNullOrEmpty(apiBasePath) ? serviceBasePath : serviceBasePath.Replace(apiBasePath, string.Empty);
+						foreach (string sPath in gxRouting.servicesValidPath[tmpPath])
+						{
+							string s = serviceBasePath + sPath;
+							routes.MapRoute($"{s}", new RequestDelegate(gxRouting.ProcessRestRequest));
+						}
 					}
-				}
-				routes.MapRoute($"{restBasePath}{{*{UrlTemplateControllerWithParms}}}", new RequestDelegate(gxRouting.ProcessRestRequest));
+					routes.MapRoute($"{restBasePath}{{*{UrlTemplateControllerWithParms}}}", new RequestDelegate(gxRouting.ProcessRestRequest));
+				});
+			}
+			app.UseMvc(routes =>
+			{
 				routes.MapRoute("Default", VirtualPath, new { controller = "Home", action = "Index" });
 			});
-			
+
 			app.UseWebSockets();
 			string basePath = string.IsNullOrEmpty(VirtualPath) ? string.Empty : $"/{VirtualPath}";
 			Config.ScriptPath = string.IsNullOrEmpty(basePath) ? "/" : basePath;
@@ -618,4 +727,29 @@ public IActionResult Index()
 			return Redirect(defaultFiles[0]);
 		}
 	}
+	internal class SetRoutePrefix : IApplicationModelConvention
+	{
+		private readonly AttributeRouteModel _routePrefix ;
+		public SetRoutePrefix(IRouteTemplateProvider route)
+		{
+			_routePrefix = new AttributeRouteModel(route);
+		}
+		public void Apply(ApplicationModel application)
+		{
+			foreach (var controller in application.Controllers)
+			{
+				foreach (var selector in controller.Selectors)
+				{
+					if (selector.AttributeRouteModel != null)
+					{
+						selector.AttributeRouteModel = AttributeRouteModel.CombineAttributeRouteModel(_routePrefix, selector.AttributeRouteModel);
+					}
+					else
+					{
+						selector.AttributeRouteModel = _routePrefix;
+					}
+				}
+			}
+		}
+	}
 }