More on downloads

Author: FlorianRappl

CHANGELOG.md

@@ -5,7 +5,10 @@ Released on Thursday, May 2 2019.
 - Reference latest AngleSharp
 - Added `InputFile` class as a standard `IFile` implementation
 - Added `AppendFile` extensions for `IHtmlInputElement`
+- Included `WithDownload` and `WithStandardDownload` configuration
 - Added ability for binary data restore on assets (#19)
+- Added `DownloadAsync` extension method to `IUrlUtilities` elements
+- Added more extension methods to `IResponse` (e.g., `SaveToAsync`)
 
 # 0.10.1
 

src/AngleSharp.Io.Tests/Integration/DownloadTest.cs

@@ -53,5 +53,23 @@ public async Task DownloadBinaryNotReceived()
             Assert.IsNotNull(linkedDocument);
             Assert.AreNotEqual(document, context.Active);
         }
+
+        [Test]
+        public async Task StandardDownloadBinary()
+        {
+            var downloadSeen = default(string);
+            var config = Configuration.Default.WithStandardDownload((name, content) =>
+            {
+                downloadSeen = name;
+                content.Dispose();
+            });
+            var context = BrowsingContext.New(config);
+            var document = await context.OpenAsync(req => req.Content("<a href=\"http://example.com/setup.exe\">Download setup</a>"));
+            var linkedDownload = await document.QuerySelector<IHtmlAnchorElement>("a").NavigateAsync();
+
+            Assert.AreEqual("setup.exe", downloadSeen);
+            Assert.IsNull(linkedDownload);
+            Assert.AreEqual(document, context.Active);
+        }
     }
 }

src/AngleSharp.Io/Dom/ElementExtensions.cs

@@ -0,0 +1,99 @@
+namespace AngleSharp.Io.Dom
+{
+    using AngleSharp.Dom;
+    using AngleSharp.Html;
+    using AngleSharp.Html.Dom;
+    using System;
+    using System.IO;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// Extensions for DOM elements.
+    /// </summary>
+    public static class ElementExtensions
+    {
+        /// <summary>
+        /// Appends a file to the input element.
+        /// Requires the input element to be of type "file".
+        /// </summary>
+        /// <typeparam name="TElement">The type of element.</typeparam>
+        /// <param name="input">The input to append to.</param>
+        /// <param name="file">The file to append.</param>
+        /// <returns>The input itself for chaining.</returns>
+        public static TElement AppendFile<TElement>(this TElement input, InputFile file)
+            where TElement : class, IHtmlInputElement
+        {
+            input = input ?? throw new ArgumentNullException(nameof(input));
+
+            if (input.Type == InputTypeNames.File)
+            {
+                input.Files.Add(file ?? throw new ArgumentNullException(nameof(file)));
+            }
+
+            return input;
+        }
+
+        /// <summary>
+        /// Appends a file to the input element.
+        /// Requires the input element to be of type "file".
+        /// </summary>
+        /// <typeparam name="TElement">The type of element.</typeparam>
+        /// <param name="input">The input to append to.</param>
+        /// <param name="filePath">The path to the file, which should be appended.</param>
+        /// <returns>The input itself for chaining.</returns>
+        public static TElement AppendFile<TElement>(this TElement input, String filePath)
+            where TElement : class, IHtmlInputElement
+        {
+            filePath = filePath ?? throw new ArgumentNullException(nameof(filePath));
+            var name = Path.GetFileName(filePath);
+            var ext = Path.GetExtension(filePath);
+            var type = MimeTypeNames.FromExtension(ext);
+            var stream = File.OpenRead(filePath);
+            var modified = File.GetLastWriteTimeUtc(filePath);
+            var file = new InputFile(name, type, stream, modified);
+            return input.AppendFile(file);
+        }
+
+        /// <summary>
+        /// Appends a file to the input element.
+        /// Requires the input element to be of type "file".
+        /// </summary>
+        /// <typeparam name="TElement">The type of element.</typeparam>
+        /// <param name="input">The input to append to.</param>
+        /// <param name="fileName">The name to the file, which should be appended.</param>
+        /// <param name="content">The content to the file, which should be appended.</param>
+        /// <param name="mimeType">
+        /// The MIME type of the file, which should be appended.
+        /// If not given the default value is maps to an unknown binary (octet stream).
+        /// </param>
+        /// <returns>The input itself for chaining.</returns>
+        public static TElement AppendFile<TElement>(this TElement input, String fileName, Stream content, String mimeType = null)
+            where TElement : class, IHtmlInputElement
+        {
+            fileName = fileName ?? throw new ArgumentNullException(nameof(fileName));
+            content = content ?? throw new ArgumentNullException(nameof(content));
+            var type = mimeType ?? MimeTypeNames.Binary;
+            var file = new InputFile(fileName, type, content);
+            return input.AppendFile(file);
+        }
+
+        /// <summary>
+        /// Downloads the content from to the hyper reference given by the provided
+        /// element.
+        /// </summary>
+        /// <typeparam name="TElement">The type of element.</typeparam>
+        /// <param name="element">The element referencing the link to follow.</param>
+        /// <param name="cancellationToken">The token to cancel the download.</param>
+        /// <returns>The task eventually resulting in the response.</returns>
+        public static Task<IResponse> DownloadAsync<TElement>(this TElement element, CancellationToken cancellationToken = default(CancellationToken))
+            where TElement : class, IUrlUtilities, IElement
+        {
+            var context = element?.Owner.Context ?? throw new InvalidOperationException("The element needs to be inside a browsing context.");
+            var loader = context.GetService<IDocumentLoader>() ?? throw new InvalidOperationException("A document loader is required. Check your configuration.");
+            var download = loader.FetchAsync(new DocumentRequest(new Url(element.Href)));
+            cancellationToken.Register(download.Cancel);
+            return download.Task;
+        }
+    }
+}

src/AngleSharp.Io/Dom/HtmlInputElementExtensions.cs

@@ -4,6 +4,7 @@ namespace AngleSharp
     using AngleSharp.Io;
     using AngleSharp.Io.Network;
     using System;
+    using System.IO;
     using System.Linq;
     using System.Net.Http;
 
@@ -21,13 +22,39 @@ public static class IoConfigurationExtensions
         /// The callback to invoke when a download should be started. Returns true
         /// to signal an interest in downloading the response, otherwise false.
         /// </param>
-        /// <returns>The configuration.</returns>
+        /// <returns>The new configuration.</returns>
         public static IConfiguration WithDownload(this IConfiguration configuration, Func<MimeType, IResponse, Boolean> download)
         {
             var oldFactory = configuration.Services.OfType<IDocumentFactory>().FirstOrDefault();
             var newFactory = new DownloadFactory(oldFactory, download);
             return configuration.WithOnly<IDocumentFactory>(newFactory);
         }
+
+        /// <summary>
+        /// Adds the standard download capability, i.e., when a binary or attachment
+        /// is received the download callback is triggered.
+        /// </summary>
+        /// <param name="configuration">The configuration to extend.</param>
+        /// <param name="download">
+        /// The callback with filename and stream as parameters. The stream must be
+        /// disposed / cleaned up after use.
+        /// </param>
+        /// <returns>The new configuration.</returns>
+        public static IConfiguration WithStandardDownload(this IConfiguration configuration, Action<String, Stream> download)
+        {
+            var binary = new MimeType(MimeTypeNames.Binary);
+            return configuration.WithDownload((type, response) =>
+            {
+                if (response.IsAttachment() || type == binary)
+                {
+                    var fileName = response.GetAttachedFileName();
+                    download.Invoke(fileName, response.Content);
+                    return true;
+                }
+
+                return false;
+            });
+        }
 
         /// <summary>
         /// Adds the requesters from the AngleSharp.Io package.

src/AngleSharp.Io/IoConfigurationExtensions.cs

@@ -0,0 +1,104 @@
+namespace AngleSharp.Io.Network
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// A set of useful extension methods for an IResponse.
+    /// </summary>
+    public static class ResponseExtensions
+    {
+        /// <summary>
+        /// Saves the given response to the given file path.
+        /// Disposes the response after saving has finished.
+        /// </summary>
+        /// <param name="response">The response to use.</param>
+        /// <param name="filePath">The path where the response should be saved.</param>
+        /// <returns>The task storing the file.</returns>
+        public static async Task SaveToAsync(this IResponse response, String filePath)
+        {
+            using (var target = File.OpenWrite(filePath))
+            {
+                await response.CopyToAsync(target).ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Copies the given response to the provided stream.
+        /// Disposes the response after saving has finished.
+        /// </summary>
+        /// <param name="response">The response to use.</param>
+        /// <param name="stream">The stream where the response should be copied to.</param>
+        /// <returns>The task copying to the stream.</returns>
+        public static async Task CopyToAsync(this IResponse response, Stream stream)
+        {
+            using (response)
+            {
+                await response.Content.CopyToAsync(stream).ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Determines if the given response is provided as an attachment.
+        /// </summary>
+        /// <param name="response">The response to extend.</param>
+        /// <returns>True if the content-disposition is attachment, otherwise false.</returns>
+        public static Boolean IsAttachment(this IResponse response) =>
+            response.Headers.TryGetValue(HeaderNames.ContentDisposition, out var disposition) &&
+            disposition.StartsWith("attachment", StringComparison.InvariantCultureIgnoreCase);
+
+        /// <summary>
+        /// Gets the filename of the content-disposition header or
+        /// alternatively via a path analysis together with the MIME type.
+        /// </summary>
+        /// <param name="response">The response to extend.</param>
+        /// <returns>The determined file name.</returns>
+        public static String GetAttachedFileName(this IResponse response)
+        {
+            var dispositionFileName = default(String);
+
+            if (response.Headers.TryGetValue(HeaderNames.ContentDisposition, out var disposition))
+            {
+                dispositionFileName = GetFileNameFromDisposition(disposition);
+            }
+
+            var filename = dispositionFileName ?? response.Address.Path.Split('/').LastOrDefault() ?? "_";
+            var standardExtension = Path.GetExtension(filename);
+
+            if (String.IsNullOrEmpty(standardExtension))
+            {
+                var type = response.GetContentType(MimeTypeNames.Binary).Content;
+                var extension = MimeTypeNames.GetExtension(type);
+                return filename + extension;
+            }
+
+
+            return filename;
+        }
+
+        private static String GetFileNameFromDisposition(String value)
+        {
+            if (!String.IsNullOrEmpty(value))
+            {
+                var head = "filename=\"";
+                var start = value.IndexOf(head) + head.Length;
+
+                if (start >= head.Length)
+                {
+                    var end = value.IndexOf("\"", start);
+
+                    if (end == -1)
+                    {
+                        end = value.Length;
+                    }
+
+                    return value.Substring(start, end - start);
+                }
+            }
+
+            return null;
+        }
+    }
+}