Bugfix: Swagger didn't use the new serialization logic

meceqs · Feb 22, 2019 · 20955ad · 20955ad
1 parent c5b986e
commit 20955ad
Show file tree

Hide file tree

Showing 4 changed files with 33 additions and 29 deletions.
diff --git a/src/Meceqs.AspNetCore.Swagger/MeceqsDocumentFilter.cs b/src/Meceqs.AspNetCore.Swagger/MeceqsDocumentFilter.cs
@@ -16,20 +16,20 @@ public class MeceqsDocumentFilter : IDocumentFilter
         private readonly ReceiveEndpointOptions _transportOptions;
         private readonly IOptionsMonitor<AspNetCoreReceiverOptions> _receiverOptions;
         private readonly IMessagePathConvention _messagePathConvention;
-        private readonly IEnumerable<ISerializer> _serializers;
+        private readonly ISerializationProvider _serializationProvider;
         private readonly MeceqsSwaggerOptions _meceqsOptions;
 
         public MeceqsDocumentFilter(
             IOptions<ReceiveEndpointOptions> transportOptions,
             IOptionsMonitor<AspNetCoreReceiverOptions> receiverOptions,
             IMessagePathConvention messagePathConvention,
-            IEnumerable<ISerializer> serializers,
+            ISerializationProvider serializationProvider,
             MeceqsSwaggerOptions meceqsOptions)
         {
             _transportOptions = transportOptions?.Value;
             _receiverOptions = receiverOptions;
             _messagePathConvention = messagePathConvention;
-            _serializers = serializers;
+            _serializationProvider = serializationProvider;
             _meceqsOptions = meceqsOptions;
         }
 
@@ -63,27 +63,13 @@ private void AddMessageType(MessageMetadata messageType, SwaggerDocument documen
 
             // Content Types
 
-            foreach (var serializer in _serializers)
-            {
-                if (serializer.CanSerializeType(messageType.MessageType))
-                {
-                    if (operation.Consumes == null)
-                    {
-                        operation.Consumes = new List<string>();
-                    }
-
-                    operation.Consumes.Add(serializer.ContentType);
-                }
+            var consumeTypes = _serializationProvider.GetSupportedContentTypes(messageType.MessageType);
+            operation.Consumes = new List<string>(consumeTypes);
 
-                if (messageType.ResponseType != typeof(void) && serializer.CanSerializeType(messageType.ResponseType))
-                {
-                    if (operation.Produces == null)
-                    {
-                        operation.Produces = new List<string>();
-                    }
-
-                    operation.Produces.Add(serializer.ContentType);
-                }
+            if (messageType.ResponseType != typeof(void))
+            {
+                var producesTypes = _serializationProvider.GetSupportedContentTypes(messageType.ResponseType);
+                operation.Produces = new List<string>(producesTypes);
             }
 
             // Parameters

diff --git a/src/Meceqs.HttpSender/DefaultHttpRequestMessageConverter.cs b/src/Meceqs.HttpSender/DefaultHttpRequestMessageConverter.cs
@@ -47,7 +47,7 @@ public HttpRequestMessage ConvertToRequestMessage(Envelope envelope, Uri request
                 }
 
                 // We also need to let the receiver know what result types we can handle.
-                foreach (var acceptedContentType in _serializationProvider.SupportedContentTypes)
+                foreach (var acceptedContentType in _serializationProvider.GetSupportedContentTypes())
                 {
                     request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(acceptedContentType));
                 }

diff --git a/src/Meceqs/Serialization/DefaultSerializationProvider.cs b/src/Meceqs/Serialization/DefaultSerializationProvider.cs
@@ -8,8 +8,7 @@ namespace Meceqs.Serialization
     public class DefaultSerializationProvider : ISerializationProvider
     {
         private readonly IReadOnlyList<ISerializer> _serializers;
-
-        public IReadOnlyList<string> SupportedContentTypes { get; }
+        private readonly IReadOnlyList<string> _supportedContentTypes;
 
         public DefaultSerializationProvider(IOptions<SerializationOptions> options)
         {
@@ -22,7 +21,7 @@ public DefaultSerializationProvider(IOptions<SerializationOptions> options)
                 throw new InvalidOperationException("No serializers have been configured.");
             }
 
-            SupportedContentTypes = GetSupportedContentTypes(_serializers);
+            _supportedContentTypes = GetSupportedContentTypes(_serializers);
         }
 
         public ISerializer GetSerializer(Type objectType)
@@ -62,6 +61,25 @@ public ISerializer GetSerializer(IEnumerable<string> supportedContentTypes)
             }
         }
 
+        public IReadOnlyList<string> GetSupportedContentTypes(Type objectType = null)
+        {
+            if (objectType == null)
+            {
+                return _supportedContentTypes;
+            }
+
+            List<string> supportedContentTypes = new List<string>();
+            foreach (var serializer in _serializers)
+            {
+                if (!supportedContentTypes.Contains(serializer.ContentType) && serializer.CanSerializeType(objectType))
+                {
+                    supportedContentTypes.Add(serializer.ContentType);
+                }
+            }
+
+            return supportedContentTypes;
+        }
+
         public bool TryGetSerializer(string contentType, out ISerializer serializer)
         {
             Guard.NotNull(contentType, nameof(contentType));

diff --git a/src/Meceqs/Serialization/ISerializationProvider.cs b/src/Meceqs/Serialization/ISerializationProvider.cs
@@ -6,14 +6,14 @@ namespace Meceqs.Serialization
 {
     public interface ISerializationProvider
     {
-        IReadOnlyList<string> SupportedContentTypes { get; }
-
         bool TryGetSerializer(string contentType, out ISerializer serializer);
 
         ISerializer GetSerializer(Type objectType);
 
         ISerializer GetSerializer(IEnumerable<string> supportedContentTypes);
 
+        IReadOnlyList<string> GetSupportedContentTypes(Type objectType = null);
+
         object Deserialize(string contentType, Type objectType, Stream serializedObject);
     }
 }