public override async Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext, CancellationToken cancellationToken) { var notSupportedMessage = $"The request using '{nameof(HateoasMediaTypeFormatter)}' does not have required Content-Type header '{SupportedMediaTypes.Last()}'."; if (!CheckSupportedContent(content)) { throw new NotSupportedException(notSupportedMessage); } Resource resource = value switch { IPagination pagination => _resourceFactory.Create(pagination, type), IEnumerable enumerable => _resourceFactory.Create(enumerable, type), _ => _resourceFactory.Create(value, type) }; var effectiveEncoding = SelectCharacterEncoding(content.Headers); var formattedResponse = _hateoasSerializer.SerializeResource(resource); var responseBytes = effectiveEncoding.GetBytes(formattedResponse.ToCharArray()); await writeStream.WriteAsync(responseBytes, 0, responseBytes.Length, cancellationToken); }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context) { if (context.Object is SerializableError error) { var errorOutput = JsonSerializer.Serialize(error); context.HttpContext.Response.ContentType = SupportedMediaTypes.First(); await context.HttpContext.Response.WriteAsync(errorOutput); return; } _resourceFactory ??= context.HttpContext.RequestServices.GetRequiredService <IResourceFactory>(); _hateoasSerializer ??= context.HttpContext.RequestServices.GetRequiredService <IHateoasSerializer>(); Resource resource = context.Object switch { IPagination pagination => _resourceFactory.Create(pagination, context.ObjectType), IEnumerable enumerable => _resourceFactory.Create(enumerable, context.ObjectType), _ => _resourceFactory.Create(context.Object, context.ObjectType) }; var formattedResponse = _hateoasSerializer.SerializeResource(resource); context.HttpContext.Response.ContentType = SupportedMediaTypes.Last(); await context.HttpContext.Response.WriteAsync(formattedResponse); } }
public IResource AddItem(IUrl url) { if (url == null) { throw new ArgumentNullException("url"); } var matchingItem = FindItem(url); if (matchingItem != null) { // Update existing item's InLink count matchingItem.InLinks += 1; return(matchingItem); } else { // Add new item var newItem = ResourceFactory.Create(url, CaseSensitive); newItem.InLinks = this.ItemCount == 0 ? 0 : 1; this.Items.Add(newItem); return(newItem); } }
/// <summary> /// Creates an instance of a <see cref="ISharedResource{TResource,TKey}" />. /// </summary> /// <param name="resourceFactory"> /// The resource factory to be used to create instances of the shared resource. /// Is called when there is no shared resource available. /// </param> /// <typeparam name="TResource"> /// The type of the shared resource. /// </typeparam> /// <typeparam name="TKey"> /// The type of the key resource. /// </typeparam> /// <returns> /// The instance of <see cref="ISharedResource{TResource,TKey}" />. /// </returns> public ISharedResource <TResource, TKey> Create <TResource, TKey>( IResourceFactory <TResource, TKey> resourceFactory) where TResource : IResource { return(new SharedResource <TResource, TKey>(async(key, ct) => { var resource = resourceFactory.Create(key); await resource.InitializeAsync(ct); return resource; })); }
public void Create_WithValidParameters_ReturnsValidFormattedResource <T>(T source) where T : class { // arrange var resourceLink = GetResourceLinkFromMockArrangements <T>(); var innerLinks = new List <ResourceLink>(); Resource resource; // act switch (source) { case IEnumerable enumerable: var enumerableResource = _sut.Create(enumerable, typeof(T)); innerLinks = enumerableResource.GetItems().SelectMany(x => x.Links).ToList(); resource = enumerableResource; break; case IPagination pagination: var paginationResource = _sut.Create(pagination, typeof(T)); innerLinks = paginationResource.GetItems().SelectMany(x => x.Links).ToList(); resource = paginationResource; break; default: resource = _sut.Create(source, typeof(T)); break; } // assert Assert.NotNull(resource); Assert.IsAssignableFrom <Resource>(resource); Assert.IsType <List <ResourceLink> >(resource.Links); Assert.Contains(resourceLink, resource.Links); Assert.True(innerLinks.All(l => l == resourceLink)); }