/// <summary>
        /// Initializes a new instance of the <see cref="ApiActionSample" /> class.
        /// </summary>
        /// <param name="formatter">The formatter.</param>
        /// <param name="apiDescription">The API description.</param>
        /// <param name="sampleDirection">The sample direction.</param>
        public ApiActionSample(
            MediaTypeFormatter formatter, ApiDescription apiDescription, ApiActionSampleDirection sampleDirection)
        {
            Type type = null;

            if (formatter != null)
            {
                this.MediaType = formatter.SupportedMediaTypes.First().MediaType;

                if (sampleDirection == ApiActionSampleDirection.Request)
                {
                    var requestBodyParameter =
                        apiDescription.ParameterDescriptions.FirstOrDefault(
                            p => p.Source == ApiParameterSource.FromBody);

                    type = requestBodyParameter == null
                                            ? null
                                            : requestBodyParameter.ParameterDescriptor.ParameterType;
                }
                else if (sampleDirection == ApiActionSampleDirection.Response)
                {
                    var returnTypes = apiDescription.ActionDescriptor.GetCustomAttributes<ApiReturnTypeAttribute>();

                    if (returnTypes.Any())
                    {
                        type = returnTypes.First().ReturnType;
                    }
                }
            }

            if (type != null && formatter.CanWriteType(type))
            {
                var content =
                            new ObjectContent(
                                type,
                                SampleGeneratorService.Instance.GetSampleObject(type),
                                formatter).ReadAsStringAsync().Result;

                if (this.MediaType.ToUpperInvariant().Contains("XML"))
                {
                    this.Sample = SampleGeneratorService.Instance.TryFormatXml(content);
                }
                else if (this.MediaType.ToUpperInvariant().Contains("JSON"))
                {
                    this.Sample = SampleGeneratorService.Instance.TryFormatJson(content);
                }
            }
        }
Example #2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="ObjectContent"/> class.
        /// </summary>
        /// <param name="type">The type of object this instance will contain.</param>
        /// <param name="value">The value of the object this instance will contain.</param>
        /// <param name="formatter">The formatter to use when serializing the value.</param>
        /// <param name="mediaType">The authoritative value of the content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        public ObjectContent(Type type, object value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            if (!formatter.CanWriteType(type))
            {
                throw Error.InvalidOperation(Properties.Resources.ObjectContent_FormatterCannotWriteType, formatter.GetType().FullName, type.Name);
            }

            _formatter = formatter;
            ObjectType = type;

            VerifyAndSetObject(value);
            _formatter.SetDefaultContentHeaders(type, Headers, mediaType);
        }
 private static bool IsFormatSupported(SampleDirection sampleDirection, MediaTypeFormatter formatter, Type type)
 {
     switch (sampleDirection)
     {
         case SampleDirection.Request:
             return formatter.CanReadType(type);
         case SampleDirection.Response:
             return formatter.CanWriteType(type);
     }
     return false;
 }
        public virtual object WriteSampleObjectUsingFormatter(MediaTypeFormatter formatter, object value, Type type, MediaTypeHeaderValue mediaType)
        {
            if (formatter == null)
            {
                throw new ArgumentNullException("formatter");
            }
            if (mediaType == null)
            {
                throw new ArgumentNullException("mediaType");
            }

            object sample = String.Empty;
            MemoryStream ms = null;
            HttpContent content = null;
            try
            {
                if (formatter.CanWriteType(type))
                {
                    ms = new MemoryStream();
                    content = new ObjectContent(type, value, formatter, mediaType);
                    formatter.WriteToStreamAsync(type, value, ms, content, null).Wait();
                    ms.Position = 0;
                    StreamReader reader = new StreamReader(ms);
                    string serializedSampleString = reader.ReadToEnd();
                    if (mediaType.MediaType.ToUpperInvariant().Contains("XML"))
                    {
                        serializedSampleString = TryFormatXml(serializedSampleString);
                    }
                    else if (mediaType.MediaType.ToUpperInvariant().Contains("JSON"))
                    {
                        serializedSampleString = TryFormatJson(serializedSampleString);
                    }

                    sample = new TextSample(serializedSampleString);
                }
                else
                {
                    sample = new InvalidSample(String.Format(
                        CultureInfo.CurrentCulture,
                        "Failed to generate the sample for media type '{0}'. Cannot use formatter '{1}' to write type '{2}'.",
                        mediaType,
                        formatter.GetType().Name,
                        type.Name));
                }
            }
            catch (Exception e)
            {
                sample = new InvalidSample(String.Format(
                    CultureInfo.CurrentCulture,
                    "An exception has occurred while using the formatter '{0}' to generate sample for media type '{1}'. Exception message: {2}",
                    formatter.GetType().Name,
                    mediaType.MediaType,
                    e.Message));
            }
            finally
            {
                if (ms != null)
                {
                    ms.Dispose();
                }
                if (content != null)
                {
                    content.Dispose();
                }
            }

            return sample;
        }
        private static MemoryStream Write(object obj, Type tSource, MediaTypeFormatter formatter)
        {
            bool f = formatter.CanWriteType(tSource);
            Assert.True(f);

            MemoryStream ms = new MemoryStream();

            formatter.WriteToStreamAsync(tSource, obj, ms, content: null, transportContext: null).Wait();

            ms.Position = 0;
            return ms;
        }