Add a download progress for the attachment download, use TimeSpan timeout instead of int timeout

Author: Suiram1701

API.Test/AuthentificationTests.cs

@@ -11,7 +11,7 @@ namespace API.Test;
 [TestFixture]
 internal class AuthentificationTests
 {
-    public static WebUntisClient Client { get; set; } = new("WebUntisAPI_TEST", 1000);
+    public static WebUntisClient Client { get; set; } = new("WebUntisAPI_TEST", TimeSpan.FromSeconds(2));
 
     static AuthentificationTests()
     {
@@ -34,7 +34,7 @@ public void Authentification()
     {
         try
         {
-            using WebUntisClient client = new("WebUntisAPI_TEST");
+            using WebUntisClient client = new("WebUntisAPI_TEST", TimeSpan.FromSeconds(2));
             client.LoginAsync(s_Server, s_LoginName, s_UserName, s_Password).Wait();
             client.LogoutAsync().Wait();
         }

WebUntisAPI.Client/Models/Messages/Attachment.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -31,16 +32,17 @@ public struct Attachment
         internal readonly string _id;
 
         /// <summary>
-        /// Get the content of the attachment as stream
+        /// Get the content of the attachment as stream with a progress report
         /// </summary>
         /// <param name="client">The client with them you got this instane (It doesn't have to be the same client but the same account)</param>
         /// <param name="timeout">The time after that the download of the content will cancelled (In miliseconds)</param>
+        /// <param name="progress">The progress of the download in percent</param>
         /// <param name="ct">Cancellation token</param>
         /// <returns>The attachment as stream</returns>
         /// <exception cref="ObjectDisposedException">Thrown when the instance was disposed</exception>
         /// <exception cref="UnauthorizedAccessException">Thrown when you're logged in</exception>
         /// <exception cref="HttpRequestException">Thrown when an error happened while the http request</exception>
-        public async Task<Stream> DownloadContentAsStreamAsync(WebUntisClient client, int timeout = 2000, CancellationToken ct = default)
+        public async Task<Stream> DownloadContentAsStreamAsync(WebUntisClient client, TimeSpan timeout, IProgress<double> progress = null, CancellationToken ct = default)
         {
             string storageResponseString = await client.MakeAPIGetRequestAsync($"/WebUntis/api/rest/view/v1/messages/{_id}/attachmentstorageurl", ct);
 
@@ -64,24 +66,44 @@ public async Task<Stream> DownloadContentAsStreamAsync(WebUntisClient client, in
 
             using (HttpClient downloadClient = new HttpClient())
             {
-                downloadClient.Timeout = TimeSpan.FromMilliseconds(timeout);
-                HttpResponseMessage response = await downloadClient.SendAsync(request, ct);
+                downloadClient.Timeout = timeout;
+                HttpResponseMessage response = await downloadClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct);
 
-                // Check cancellation token
-                if (ct.IsCancellationRequested)
-                    return default;
+                using (MemoryStream content = new MemoryStream())
+                {
+                    using (Stream contentStream = await response.Content.ReadAsStreamAsync())
+                    {
+                        int totalBytes = (int?)response.Content.Headers.ContentLength ?? -1;
+                        int totalRecievedBytes = 0;
 
-                // Verify response
-                if (response.StatusCode != HttpStatusCode.OK)
-                    throw new HttpRequestException($"There was an error while the http request (Code: {response.StatusCode}).");
+                        int bytesRead = 0;
+                        byte[] buffer = new byte[8192];
+                        while ((bytesRead = await contentStream.ReadAsync(buffer, 0, buffer.Length, ct)) > 0)
+                        {
+                            if (ct.IsCancellationRequested)
+                                return default;
 
-                if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden)
-                {
-                    string detail = Regex.Match(await response.Content.ReadAsStringAsync(), @"<Message>([a-zA-z0-9\s]+)</Message>").Groups[1].Value;     // Get the error message
-                    throw new UnauthorizedAccessException($"Invalid authentication. Detail: {detail}");
-                }
+                            content.Write(buffer, 0, bytesRead);
+                            totalRecievedBytes += bytesRead;
+                            progress.Report((double)totalRecievedBytes / totalBytes * 100d);
+                        }
+                    }
+
+                    if (ct.IsCancellationRequested)
+                        return default;
 
-                return await response.Content.ReadAsStreamAsync();
+                    // Verify response
+                    if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden)
+                    {
+                        string detail = Regex.Match(Encoding.UTF8.GetString(content.ToArray()), @"<Message>([a-zA-z0-9\s]+)</Message>").Groups[1].Value;     // Get the error message
+                        throw new UnauthorizedAccessException($"Invalid authentication. Detail: {detail}");
+                    }
+
+                    if (response.StatusCode != HttpStatusCode.OK)
+                        throw new HttpRequestException($"There was an error while the http request (Code: {response.StatusCode}).");
+
+                    return content;
+                }
             }
         }
     }

WebUntisAPI.Client/WebUntisClient.Messages.cs

@@ -91,15 +91,15 @@ public async Task<MessagePreview[]> GetMessageInboxAsync(CancellationToken ct =
         /// <exception cref="ObjectDisposedException">Thrown when the instance was disposed</exception>
         /// <exception cref="UnauthorizedAccessException">Thrown when you're logged in</exception>
         /// <exception cref="HttpRequestException">Thrown when an error happened while the http request</exception>
-        public async Task<MessagePreview> SendMessageAsync(Draft draft, MessagePerson[] recipients, int timeout = 2000, CancellationToken ct = default)
+        public async Task<MessagePreview> SendMessageAsync(Draft draft, MessagePerson[] recipients, TimeSpan timeout, CancellationToken ct = default)
         {
             Tuple<string, Stream>[] attachments = new Tuple<string, Stream>[0];
             if (draft.Attachments.Count > 0)
             {
                 Dictionary<string, Task<Stream>> attachmentTasks = new Dictionary<string, Task<Stream>>();
 
                 foreach (Attachment attachment in draft.Attachments)
-                    attachmentTasks.Add(attachment.Name, attachment.DownloadContentAsStreamAsync(this, timeout, ct));
+                    attachmentTasks.Add(attachment.Name, attachment.DownloadContentAsStreamAsync(this, timeout, ct: ct));
 
                 await Task.WhenAll(attachmentTasks.Values);
                 attachments = attachmentTasks.Select(attachment => new Tuple<string, Stream>(attachment.Key, attachment.Value.Result)).ToArray();

WebUntisAPI.Client/WebUntisClient.cs

@@ -26,11 +26,6 @@ public partial class WebUntisClient : IDisposable
         /// </summary>
         public string ClientName { get; }
 
-        /// <summary>
-        /// The time in milliseconds until requests will be timeouted
-        /// </summary>
-        public int Timeout { get; }
-
         /// <summary>
         /// <see langword="true"/> when the client is currently logged in
         /// </summary>
@@ -74,13 +69,12 @@ public partial class WebUntisClient : IDisposable
         /// </summary>
         /// <param name="clientName">Unique identifier for the client app</param>
         /// <param name="timeout">The time in milliseconds until requests will be timeouted</param>
-        public WebUntisClient(string clientName, int timeout = 1000)
+        public WebUntisClient(string clientName, TimeSpan timeout)
         {
             ClientName = clientName;
-            Timeout = timeout;
             _client = new HttpClient()
             {
-                Timeout = TimeSpan.FromMilliseconds(Timeout)
+                Timeout = timeout
             };
         }