#1397 Add polymorphism support to generated OpenAPI json and UI:

yecli · yecli · commit 2432b60fd754 · 2019-05-07T17:02:48.000+05:00
- Added IPolymorphismRegistrar to register polymorphic types and their discriminator fields for the modules. AbstractTypeFactory is used for getting registered descendant types;
diff --git a/VirtoCommerce.Platform.Core/Common/IPolymorphicBaseTypeInfo.cs b/VirtoCommerce.Platform.Core/Common/IPolymorphicBaseTypeInfo.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+
+namespace VirtoCommerce.Platform.Core.Common
+{
+    public interface IPolymorphicBaseTypeInfo
+    {
+        Type Type { get; }
+        string DiscriminatorName { get; }
+        IEnumerable<Type> DerivedTypes { get; }
+    }
+}
diff --git a/VirtoCommerce.Platform.Core/Common/IPolymorphismRegistrar.cs b/VirtoCommerce.Platform.Core/Common/IPolymorphismRegistrar.cs
@@ -0,0 +1,8 @@
+namespace VirtoCommerce.Platform.Core.Common
+{
+    public interface IPolymorphismRegistrar
+    {
+        IPolymorphicBaseTypeInfo[] GetPolymorphicBaseTypes(string moduleName);
+        void RegisterPolymorphicBaseType(string moduleName, IPolymorphicBaseTypeInfo polymorphismBaseTypeInfo);
+    }
+}
diff --git a/VirtoCommerce.Platform.Core/Common/PolymorphicBaseTypeInfo.cs b/VirtoCommerce.Platform.Core/Common/PolymorphicBaseTypeInfo.cs
@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace VirtoCommerce.Platform.Core.Common
+{
+    public class PolymorphicBaseTypeInfo<T> : IPolymorphicBaseTypeInfo
+    {
+        public PolymorphicBaseTypeInfo(string discriminatorName)
+        {
+            if (discriminatorName.IsNullOrEmpty())
+            {
+                throw new ArgumentException($"\"{ nameof(discriminatorName) }\" cannot be null or empty");
+            }
+
+            DiscriminatorName = discriminatorName;
+        }
+
+        public Type Type { get => typeof(T); }
+        public string DiscriminatorName { get; private set; }
+        public IEnumerable<Type> DerivedTypes { get => AbstractTypeFactory<T>.AllTypeInfos.SelectMany(x => x.AllSubclasses); }
+    }
+}
diff --git a/VirtoCommerce.Platform.Core/Common/PolymorphismRegistrar.cs b/VirtoCommerce.Platform.Core/Common/PolymorphismRegistrar.cs
@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace VirtoCommerce.Platform.Core.Common
+{
+    public class PolymorphismRegistrar : IPolymorphismRegistrar
+    {
+        private readonly Dictionary<string, HashSet<IPolymorphicBaseTypeInfo>> _modulePolymorphicTypes = new Dictionary<string, HashSet<IPolymorphicBaseTypeInfo>>(StringComparer.InvariantCultureIgnoreCase);
+
+        public void RegisterPolymorphicBaseType(string moduleName, IPolymorphicBaseTypeInfo polymorphismBaseTypeInfo)
+        {
+            if (moduleName == null)
+            {
+                throw new ArgumentNullException(nameof(moduleName));
+            }
+
+            if (polymorphismBaseTypeInfo == null)
+            {
+                throw new ArgumentNullException(nameof(polymorphismBaseTypeInfo));
+            }
+
+            if (!_modulePolymorphicTypes.ContainsKey(moduleName))
+            {
+                _modulePolymorphicTypes.Add(moduleName, new HashSet<IPolymorphicBaseTypeInfo>(AnonymousComparer.Create<IPolymorphicBaseTypeInfo, string>(x => x.Type.FullName)));
+            }
+
+            if (_modulePolymorphicTypes[moduleName].Contains(polymorphismBaseTypeInfo))
+            {
+                throw new ArgumentException($"\"{polymorphismBaseTypeInfo.Type.FullName}\" polymorphic base type already registered for \"{moduleName}\" module.");
+            }
+
+            _modulePolymorphicTypes[moduleName].Add(polymorphismBaseTypeInfo);
+        }
+
+        public IPolymorphicBaseTypeInfo[] GetPolymorphicBaseTypes(string moduleName)
+        {
+            var result = Array.Empty<IPolymorphicBaseTypeInfo>();
+
+            var needAllTypes = string.IsNullOrEmpty(moduleName);
+
+            if (needAllTypes)
+            {
+                result = _modulePolymorphicTypes.Values.SelectMany(x => x).Distinct().ToArray();
+            }
+
+            if (!needAllTypes && _modulePolymorphicTypes.ContainsKey(moduleName))
+            {
+                result = _modulePolymorphicTypes[moduleName].ToArray();
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/VirtoCommerce.Platform.Core/VirtoCommerce.Platform.Core.csproj b/VirtoCommerce.Platform.Core/VirtoCommerce.Platform.Core.csproj
@@ -75,9 +75,13 @@
     <Compile Include="Common\ICancellationToken.cs" />
     <Compile Include="Common\IEntity.cs" />
     <Compile Include="Common\IFactory.cs" />
+    <Compile Include="Common\IPolymorphicBaseTypeInfo.cs" />
+    <Compile Include="Common\IPolymorphismRegistrar.cs" />
     <Compile Include="Common\IValueObject.cs" />
     <Compile Include="Common\ObservableChangeTracker.cs" />
     <Compile Include="Common\PlatformVersion.cs" />
+    <Compile Include="Common\PolymorphicBaseTypeInfo.cs" />
+    <Compile Include="Common\PolymorphismRegistrar.cs" />
     <Compile Include="Common\PredicateBuilder.cs" />
     <Compile Include="Common\PrimaryKeyResolvingMap.cs" />
     <Compile Include="Common\SemanticVersion.cs" />
diff --git a/VirtoCommerce.Platform.Web/Startup.cs b/VirtoCommerce.Platform.Web/Startup.cs
@@ -863,6 +863,12 @@ private static void InitializePlatform(
             inProcessBus.RegisterHandler<UserPasswordChangedEvent>(async (message, token) => await container.Resolve<LogChangesUserChangedEventHandler>().Handle(message));
             inProcessBus.RegisterHandler<UserResetPasswordEvent>(async (message, token) => await container.Resolve<LogChangesUserChangedEventHandler>().Handle(message));
             #endregion
+
+            #region Polymorphism registrar
+
+            container.RegisterInstance<IPolymorphismRegistrar>(new PolymorphismRegistrar());
+
+            #endregion 
         }
 
         private static string NormalizePath(IPathMapper pathMapper, string path)
diff --git a/VirtoCommerce.Platform.Web/Swagger/PolymorphismDocumentFilter.cs b/VirtoCommerce.Platform.Web/Swagger/PolymorphismDocumentFilter.cs
@@ -1,36 +1,41 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Swashbuckle.Swagger;
+using VirtoCommerce.Platform.Core.Common;
 
 namespace VirtoCommerce.Platform.Web.Swagger
 {
     public class PolymorphismDocumentFilter : IDocumentFilter
     {
-        private readonly Type[] _types;
+        private readonly string _moduleName;
+        private readonly IPolymorphismRegistrar _polymorphismRegistrar;
+        private readonly bool _useFullTypeNames;
 
-        public PolymorphismDocumentFilter(Type[] types)
+        public PolymorphismDocumentFilter(IPolymorphismRegistrar polymorphismRegistrar, string moduleName, bool useFullTypeNames)
         {
-            _types = types;
+            _polymorphismRegistrar = polymorphismRegistrar ?? throw new ArgumentNullException(nameof(polymorphismRegistrar));
+            _moduleName = moduleName;
+            _useFullTypeNames = useFullTypeNames;
         }
 
         [CLSCompliant(false)]
         public void Apply(SwaggerDocument swaggerDoc, SchemaRegistry schemaRegistry, System.Web.Http.Description.IApiExplorer apiExplorer)
         {
-            foreach (var type in _types)
+            foreach (var polymorphicBaseTypeInfo in _polymorphismRegistrar.GetPolymorphicBaseTypes(_moduleName))
             {
-                RegisterSubClasses(schemaRegistry, type);
+                RegisterSubClasses(schemaRegistry, polymorphicBaseTypeInfo);
             }
         }
 
-        private static void RegisterSubClasses(SchemaRegistry schemaRegistry, Type abstractType)
+        private void RegisterSubClasses(SchemaRegistry schemaRegistry, IPolymorphicBaseTypeInfo polymorphicBaseTypeInfo)
         {
-            var discriminatorName = "type";
+            var abstractType = polymorphicBaseTypeInfo.Type;
+            var discriminatorName = polymorphicBaseTypeInfo.DiscriminatorName;
 
             // Need to make first property character lower to avoid properties duplication because of case, as all properties in OpenApi spec are in camelCase
             discriminatorName = char.ToLowerInvariant(discriminatorName[0]) + discriminatorName.Substring(1);
 
-            var typeName = schemaRegistry.Definitions.ContainsKey(abstractType.FullName) ? abstractType.FullName : abstractType.FriendlyId();
+            var typeName = _useFullTypeNames ? abstractType.FullName : abstractType.FriendlyId();
             var parentSchema = schemaRegistry.Definitions[typeName];
 
             //set up a discriminator property (it must be required)
@@ -43,9 +48,7 @@ private static void RegisterSubClasses(SchemaRegistry schemaRegistry, Type abstr
             }
 
             //register all subclasses
-            var derivedTypes = abstractType.Assembly
-                                           .GetTypes()
-                                           .Where(x => abstractType != x && abstractType.IsAssignableFrom(x));
+            var derivedTypes = polymorphicBaseTypeInfo.DerivedTypes;
 
             foreach (var item in derivedTypes)
             {
diff --git a/VirtoCommerce.Platform.Web/Swagger/PolymorphismSchemaFilter.cs b/VirtoCommerce.Platform.Web/Swagger/PolymorphismSchemaFilter.cs
@@ -2,34 +2,30 @@
 using System.Collections.Generic;
 using System.Linq;
 using Swashbuckle.Swagger;
+using VirtoCommerce.Platform.Core.Common;
 
 namespace VirtoCommerce.Platform.Web.Swagger
 {
-
     public class PolymorphismSchemaFilter : ISchemaFilter
     {
-        private readonly Type[] _types;
+        private readonly string _moduleName;
+        private readonly IPolymorphismRegistrar _polymorphismRegistrar;
         private readonly Lazy<HashSet<Type>> _derivedTypes;
+        private readonly bool _useFullTypeNames;
 
-        public PolymorphismSchemaFilter(Type[] types)
+        public PolymorphismSchemaFilter(IPolymorphismRegistrar polymorphismRegistrar, string moduleName, bool useFullTypeNames)
         {
-            _types = types;
+            _polymorphismRegistrar = polymorphismRegistrar ?? throw new ArgumentNullException(nameof(polymorphismRegistrar));
+            _moduleName = moduleName;
             _derivedTypes = new Lazy<HashSet<Type>>(Init);
+            _useFullTypeNames = useFullTypeNames;
         }
 
         private HashSet<Type> Init()
         {
             var result = new HashSet<Type>();
 
-            var derivedTypes = _types.SelectMany(baseType =>
-                baseType.Assembly
-                    .GetTypes()
-                    .Where(derivedType => baseType != derivedType && baseType.IsAssignableFrom(derivedType)));
-
-            foreach (var item in derivedTypes)
-            {
-                result.Add(item);
-            }
+            result.AddRange(_polymorphismRegistrar.GetPolymorphicBaseTypes(_moduleName).SelectMany(x => x.DerivedTypes).Distinct());
 
             return result;
         }
@@ -47,7 +43,7 @@ public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
                 };
 
                 var baseType = type.BaseType;
-                var baseTypeName = schemaRegistry.Definitions.ContainsKey(baseType.FullName) ? baseType.FullName : baseType.FriendlyId();
+                var baseTypeName = _useFullTypeNames ? baseType.FullName : baseType.FriendlyId();
 
                 var parentSchema = new Schema { @ref = "#/definitions/" + baseTypeName };
 
diff --git a/VirtoCommerce.Platform.Web/Swagger/SwaggerConfig.cs b/VirtoCommerce.Platform.Web/Swagger/SwaggerConfig.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net.Http;
@@ -33,21 +32,12 @@ public static void RegisterRoutes(IUnityContainer container)
             var xmlCommentsFilePaths = xmlCommentsDirectoryPaths.SelectMany(GetXmlFilesPaths).ToArray();
 
             // Add separate swagger generator for platform
-            EnableSwagger("VirtoCommerce.Platform", httpConfiguration, container, routePrefix, xmlCommentsFilePaths, false, Assembly.GetExecutingAssembly(), null);
+            EnableSwagger("VirtoCommerce.Platform", httpConfiguration, container, routePrefix, xmlCommentsFilePaths, false, Assembly.GetExecutingAssembly());
 
             // Add separate swagger generator for each installed module
-            var allmodules = container.Resolve<IModuleCatalog>().Modules.OfType<ManifestModuleInfo>().Where(m => m.ModuleInstance != null);
-
-            ICollection<Type> allPolymorphicTypes = new List<Type>();
-
-            // Add separate swagger generator for each installed module
-            foreach (var module in allmodules)
+            foreach (var module in container.Resolve<IModuleCatalog>().Modules.OfType<ManifestModuleInfo>().Where(m => m.ModuleInstance != null))
             {
-                var polimorphicTypes = GetPolymorphicTypes(module);
-
-                allPolymorphicTypes.AddRange(polimorphicTypes);
-
-                EnableSwagger(module.ModuleName, httpConfiguration, container, routePrefix, xmlCommentsFilePaths, module.UseFullTypeNameInSwagger, module.ModuleInstance.GetType().Assembly, polimorphicTypes);
+                EnableSwagger(module.ModuleName, httpConfiguration, container, routePrefix, xmlCommentsFilePaths, module.UseFullTypeNameInSwagger, module.ModuleInstance.GetType().Assembly);
             }
 
             // Add full swagger generator
@@ -72,7 +62,7 @@ public static void RegisterRoutes(IUnityContainer container)
                     .Replace(',', '-')
                 );
 
-                AddProlymorphicFilters(c, allPolymorphicTypes.ToArray());
+                AddProlymorphicFilters(container, c, null, true);
 
                 ApplyCommonSwaggerConfiguration(c, container, string.Empty, xmlCommentsFilePaths);
             })
@@ -91,32 +81,14 @@ public static void RegisterRoutes(IUnityContainer container)
             });
         }
 
-        private static Type[] GetPolymorphicTypes(ManifestModuleInfo module)
-        {
-            //TODO: Could move type loading to module loading mechanism with its error handling
-            Type[] polimorphicTypes = null;
-            try
-            {
-                polimorphicTypes = module.OpenAPIPolymorphicTypes
-                    .Select(x => Type.GetType(x, false))
-                    .Where(x => x != null)
-                    .ToArray();
-            }
-            // Need to add catch as even with GetType throwOnError = false it could throw
-            catch { }
-
-            return polimorphicTypes;
-        }
-
         private static void EnableSwagger(
             string moduleName,
             HttpConfiguration httpConfiguration,
             IUnityContainer container,
             string routePrefix,
             string[] xmlCommentsFilePaths,
             bool useFullTypeNameInSchemaIds,
-            Assembly apiAssembly,
-            Type[] polymorphicTypes)
+            Assembly apiAssembly)
         {
             var routeName = string.Concat("swagger_", moduleName);
             var routeTemplate = string.Concat(routePrefix, "docs/", moduleName, "/{apiVersion}");
@@ -136,17 +108,16 @@ private static void EnableSwagger(
                 ApplyCommonSwaggerConfiguration(c, container, moduleName, xmlCommentsFilePaths);
                 c.OperationFilter(() => new ModuleTagsFilter(moduleName));
 
-                AddProlymorphicFilters(c, polymorphicTypes);
+                AddProlymorphicFilters(container, c, moduleName, false);
             });
         }
 
-        private static void AddProlymorphicFilters(SwaggerDocsConfig swaggerDocsConfig, Type[] polymorphicTypes)
+        private static void AddProlymorphicFilters(IUnityContainer container, SwaggerDocsConfig swaggerDocsConfig, string moduleName, bool useFullTypeName)
         {
-            if (polymorphicTypes?.Any() == true)
-            {
-                swaggerDocsConfig.DocumentFilter(() => new PolymorphismDocumentFilter(polymorphicTypes));
-                swaggerDocsConfig.SchemaFilter(() => new PolymorphismSchemaFilter(polymorphicTypes));
-            }
+            var polymorphismRegistrar = container.Resolve<IPolymorphismRegistrar>();
+
+            swaggerDocsConfig.DocumentFilter(() => new PolymorphismDocumentFilter(polymorphismRegistrar, moduleName, useFullTypeName));
+            swaggerDocsConfig.SchemaFilter(() => new PolymorphismSchemaFilter(polymorphismRegistrar, moduleName, useFullTypeName));
         }
 
         private static Uri ComputeHostAsSeenByOriginalClient(HttpRequestMessage message)

Original file line number	Diff line number	Diff line change
`@@ -1,36 +1,41 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`		`-using System.Linq;`
`4`	`3`	`using Swashbuckle.Swagger;`
	`4`	`+using VirtoCommerce.Platform.Core.Common;`
`5`	`5`
`6`	`6`	`namespace VirtoCommerce.Platform.Web.Swagger`
`7`	`7`	`{`
`8`	`8`	`public class PolymorphismDocumentFilter : IDocumentFilter`
`9`	`9`	`{`
`10`		`- private readonly Type[] _types;`
	`10`	`+ private readonly string _moduleName;`
	`11`	`+ private readonly IPolymorphismRegistrar _polymorphismRegistrar;`
	`12`	`+ private readonly bool _useFullTypeNames;`
`11`	`13`
`12`		`- public PolymorphismDocumentFilter(Type[] types)`
	`14`	`+ public PolymorphismDocumentFilter(IPolymorphismRegistrar polymorphismRegistrar, string moduleName, bool useFullTypeNames)`
`13`	`15`	`{`
`14`		`- _types = types;`
	`16`	`+ _polymorphismRegistrar = polymorphismRegistrar ?? throw new ArgumentNullException(nameof(polymorphismRegistrar));`
	`17`	`+ _moduleName = moduleName;`
	`18`	`+ _useFullTypeNames = useFullTypeNames;`
`15`	`19`	`}`
`16`	`20`
`17`	`21`	`[CLSCompliant(false)]`
`18`	`22`	`public void Apply(SwaggerDocument swaggerDoc, SchemaRegistry schemaRegistry, System.Web.Http.Description.IApiExplorer apiExplorer)`
`19`	`23`	`{`
`20`		`- foreach (var type in _types)`
	`24`	`+ foreach (var polymorphicBaseTypeInfo in _polymorphismRegistrar.GetPolymorphicBaseTypes(_moduleName))`
`21`	`25`	`{`
`22`		`- RegisterSubClasses(schemaRegistry, type);`
	`26`	`+ RegisterSubClasses(schemaRegistry, polymorphicBaseTypeInfo);`
`23`	`27`	`}`
`24`	`28`	`}`
`25`	`29`
`26`		`- private static void RegisterSubClasses(SchemaRegistry schemaRegistry, Type abstractType)`
	`30`	`+ private void RegisterSubClasses(SchemaRegistry schemaRegistry, IPolymorphicBaseTypeInfo polymorphicBaseTypeInfo)`
`27`	`31`	`{`
`28`		`- var discriminatorName = "type";`
	`32`	`+ var abstractType = polymorphicBaseTypeInfo.Type;`
	`33`	`+ var discriminatorName = polymorphicBaseTypeInfo.DiscriminatorName;`
`29`	`34`
`30`	`35`	`// Need to make first property character lower to avoid properties duplication because of case, as all properties in OpenApi spec are in camelCase`
`31`	`36`	`discriminatorName = char.ToLowerInvariant(discriminatorName[0]) + discriminatorName.Substring(1);`
`32`	`37`
`33`		`- var typeName = schemaRegistry.Definitions.ContainsKey(abstractType.FullName) ? abstractType.FullName : abstractType.FriendlyId();`
	`38`	`+ var typeName = _useFullTypeNames ? abstractType.FullName : abstractType.FriendlyId();`
`34`	`39`	`var parentSchema = schemaRegistry.Definitions[typeName];`
`35`	`40`
`36`	`41`	`//set up a discriminator property (it must be required)`
`@@ -43,9 +48,7 @@ private static void RegisterSubClasses(SchemaRegistry schemaRegistry, Type abstr`
`43`	`48`	`}`
`44`	`49`
`45`	`50`	`//register all subclasses`
`46`		`- var derivedTypes = abstractType.Assembly`
`47`		`- .GetTypes()`
`48`		`- .Where(x => abstractType != x && abstractType.IsAssignableFrom(x));`
	`51`	`+ var derivedTypes = polymorphicBaseTypeInfo.DerivedTypes;`
`49`	`52`
`50`	`53`	`foreach (var item in derivedTypes)`
`51`	`54`	`{`