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

- Added PolymorphicBaseClassAttribute by which base classes should be marked for OpenAPI polymorphism;
- Supported OpenAPI docs generation using this attribute for independent module and common docs;

Author: yecli

VirtoCommerce.Platform.Core/Common/AttributeExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 
 namespace VirtoCommerce.Platform.Core.Common
@@ -21,5 +21,22 @@ public static string[] SplitString(this Attribute attribute, string original, ch
 
             return result;
         }
+
+        /// <summary>
+        /// Gets type attribute value https://stackoverflow.com/a/2656211/5907312
+        /// </summary>
+        /// <typeparam name="TAttribute">Attribute type</typeparam>
+        /// <typeparam name="TValue">Value type</typeparam>
+        /// <param name="type">Type for getting attribute</param>
+        /// <param name="valueSelector">Attribute value selector</param>
+        /// <returns>Attribute value</returns>
+        public static TValue GetAttributeValue<TAttribute, TValue>(
+            this Type type,
+            Func<TAttribute, TValue> valueSelector)
+            where TAttribute : Attribute
+        {
+            var att = type.GetCustomAttributes(typeof(TAttribute), true).FirstOrDefault() as TAttribute;
+            return (att != null) ? valueSelector(att) : default(TValue);
+        }
     }
 }

VirtoCommerce.Platform.Core/Common/PolymorphicBaseClassAttribute.cs

@@ -0,0 +1,16 @@
+using System;
+
+namespace VirtoCommerce.Platform.Core.Common
+{
+    /// <summary>
+    /// Class marked with this attribute is marked as a base class for OpenAPI polymorphism
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class PolymorphicBaseClassAttribute : Attribute
+    {
+        /// <summary>
+        /// The property name used to store type information, in camelCase. By default: "type".
+        /// </summary>
+        public string DiscriminatorPropertyName { get; set; } = "type";
+    }
+}

VirtoCommerce.Platform.Core/VirtoCommerce.Platform.Core.csproj

@@ -78,6 +78,7 @@
     <Compile Include="Common\IValueObject.cs" />
     <Compile Include="Common\ObservableChangeTracker.cs" />
     <Compile Include="Common\PlatformVersion.cs" />
+    <Compile Include="Common\PolymorphicBaseClassAttribute.cs" />
     <Compile Include="Common\PredicateBuilder.cs" />
     <Compile Include="Common\PrimaryKeyResolvingMap.cs" />
     <Compile Include="Common\SemanticVersion.cs" />

VirtoCommerce.Platform.Data/Common/AssemblyExtensions.cs

@@ -1,17 +1,16 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace VirtoCommerce.Platform.Data.Common
 {
     public static class AssemblyExtensions
     {
         public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly)
         {
-            if (assembly == null) throw new ArgumentNullException("assembly");
+            if (assembly == null)
+                throw new ArgumentNullException("assembly");
             try
             {
                 return assembly.GetTypes();
@@ -21,5 +20,34 @@ public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly)
                 return e.Types.Where(t => t != null);
             }
         }
+
+        /// <summary>
+        /// Gets all assembly types with custom attribute specified.
+        /// </summary>
+        /// <param name="assembly">Assembly to get types</param>
+        /// <param name="customAttributeType">Custom attribute type to check</param>
+        /// <param name="inherited"></param>
+        /// <returns></returns>
+        public static IEnumerable<Type> GetTypesWithAttribute(this Assembly assembly, Type customAttributeType, bool inherited)
+        {
+            if (assembly == null)
+            {
+                throw new ArgumentNullException(nameof(assembly));
+            }
+
+            if (customAttributeType == null)
+            {
+                throw new ArgumentNullException(nameof(customAttributeType));
+            }
+
+            try
+            {
+                return assembly.GetTypes().Where(x => x.GetCustomAttributes(customAttributeType, inherited).Length > 0);
+            }
+            catch (ReflectionTypeLoadException e)
+            {
+                return e.Types.Where(x => x.GetCustomAttributes(customAttributeType, inherited).Length > 0);
+            }
+        }
     }
 }

VirtoCommerce.Platform.Web/Controllers/Api/PolyController.cs

@@ -0,0 +1,57 @@
+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;
+
+        public PolymorphismDocumentFilter(Type[] types)
+        {
+            _types = types;
+        }
+
+        [CLSCompliant(false)]
+        public void Apply(SwaggerDocument swaggerDoc, SchemaRegistry schemaRegistry, System.Web.Http.Description.IApiExplorer apiExplorer)
+        {
+            foreach (var type in _types)
+            {
+                RegisterSubClasses(schemaRegistry, type);
+            }
+        }
+
+        private static void RegisterSubClasses(SchemaRegistry schemaRegistry, Type abstractType)
+        {
+            var discriminatorName = abstractType.GetAttributeValue<PolymorphicBaseClassAttribute, string>(x => x.DiscriminatorPropertyName) ?? "type";
+
+            // 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 parentSchema = schemaRegistry.Definitions[typeName];
+
+            //set up a discriminator property (it must be required)
+            parentSchema.discriminator = discriminatorName;
+            parentSchema.required = new List<string> { discriminatorName };
+
+            if (!parentSchema.properties.ContainsKey(discriminatorName))
+            {
+                parentSchema.properties.Add(discriminatorName, new Schema { type = "string" });
+            }
+
+            //register all subclasses
+            var derivedTypes = abstractType.Assembly
+                                           .GetTypes()
+                                           .Where(x => abstractType != x && abstractType.IsAssignableFrom(x));
+
+            foreach (var item in derivedTypes)
+            {
+                schemaRegistry.GetOrRegister(item);
+            }
+        }
+    }
+}

VirtoCommerce.Platform.Web/Swagger/PolymorphismDocumentFilter.cs

@@ -6,79 +6,54 @@
 namespace VirtoCommerce.Platform.Web.Swagger
 {
 
-    public class PolymorphismSchemaFilter<T> : ISchemaFilter
+    public class PolymorphismSchemaFilter : ISchemaFilter
     {
-        private readonly Lazy<HashSet<Type>> derivedTypes = new Lazy<HashSet<Type>>(Init);
+        private readonly Type[] _types;
+        private readonly Lazy<HashSet<Type>> _derivedTypes;
 
-        private static HashSet<Type> Init()
+        public PolymorphismSchemaFilter(Type[] types)
         {
-            var abstractType = typeof(T);
-            var dTypes = abstractType.Assembly
-                                     .GetTypes()
-                                     .Where(x => abstractType != x && abstractType.IsAssignableFrom(x));
+            _types = types;
+            _derivedTypes = new Lazy<HashSet<Type>>(Init);
+        }
 
+        private HashSet<Type> Init()
+        {
             var result = new HashSet<Type>();
 
-            foreach (var item in dTypes)
+            var derivedTypes = _types.SelectMany(x =>
+                x.Assembly
+                .GetTypes()
+                .Where(y => x != y && y.IsAssignableFrom(x)));
+
+            foreach (var item in derivedTypes)
+            {
                 result.Add(item);
+            }
 
             return result;
         }
 
         [CLSCompliant(false)]
         public void Apply(Schema schema, SchemaRegistry schemaRegistry, Type type)
         {
-            if (!derivedTypes.Value.Contains(type))
-                return;
-
-            var clonedSchema = new Schema
+            if (_derivedTypes.Value.Contains(type))
             {
-                properties = schema.properties,
-                type = schema.type,
-                required = schema.required
-            };
+                var clonedSchema = new Schema
+                {
+                    properties = schema.properties,
+                    type = schema.type,
+                    required = schema.required
+                };
 
-            //schemaRegistry.Definitions[typeof(T).Name]; does not work correctly in SwashBuckle
-            var parentSchema = new Schema { @ref = "#/definitions/" + typeof(T).Name };
+                //schemaRegistry.Definitions[typeof(T).Name]; does not work correctly in SwashBuckle
+                var parentSchema = new Schema { @ref = "#/definitions/" + type.BaseType.Name };
 
-            schema.allOf = new List<Schema> { parentSchema, clonedSchema };
+                schema.allOf = new List<Schema> { parentSchema, clonedSchema };
 
-            //reset properties for they are included in allOf, should be null but code does not handle it
-            schema.properties = new Dictionary<string, Schema>();
-        }
-    }
-
-
-    public class PolymorphismDocumentFilter<T> : IDocumentFilter
-    {
-        [CLSCompliant(false)]
-        public void Apply(SwaggerDocument swaggerDoc, SchemaRegistry schemaRegistry, System.Web.Http.Description.IApiExplorer apiExplorer)
-        {
-            RegisterSubClasses(schemaRegistry, typeof(T));
-        }
-
-
-        private static void RegisterSubClasses(SchemaRegistry schemaRegistry, Type abstractType)
-        {
-            const string discriminatorName = "type";
-
-            var typeName = schemaRegistry.Definitions.ContainsKey(abstractType.FullName) ? abstractType.FullName : abstractType.FriendlyId();
-            var parentSchema = schemaRegistry.Definitions[typeName];
-
-            //set up a discriminator property (it must be required)
-            parentSchema.discriminator = discriminatorName;
-            parentSchema.required = new List<string> { discriminatorName };
-
-            if (!parentSchema.properties.ContainsKey(discriminatorName))
-                parentSchema.properties.Add(discriminatorName, new Schema { type = "string" });
-
-            //register all subclasses
-            var derivedTypes = abstractType.Assembly
-                                           .GetTypes()
-                                           .Where(x => abstractType != x && abstractType.IsAssignableFrom(x));
-
-            foreach (var item in derivedTypes)
-                schemaRegistry.GetOrRegister(item);
+                //reset properties for they are included in allOf, should be null but code does not handle it
+                schema.properties = new Dictionary<string, Schema>();
+            }
         }
     }
 }