Merge branch 'release/v1.0.0'

Author: Suiram1701

API.Test/MessagesTests.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WebUntisAPI.Client.Models.Messages;
+using static API.Test.AuthentificationTests;
+
+namespace API.Test;
+
+internal class MessagesTests
+{
+    [Test]
+    public void GetUnreadMessages()
+    {
+        Client.LoginAsync(s_Server, s_LoginName, s_UserName, s_Password).Wait();
+
+        Task<int> messages = Client.GetUnreadMessagesCountAsync();
+        messages.Wait();
+        if (messages.Result == 0)
+            Assert.Pass();
+        else
+            Assert.Fail();
+    }
+
+    [Test]
+    public void GetMessagePermissions()
+    {
+        Client.LoginAsync(s_Server, s_LoginName, s_UserName, s_Password).Wait();
+
+        Task<MessagePermissions> permissions = Client.GetMessagePermissionsAsync();
+        permissions.Wait();
+        if (permissions.Result != null)
+            Assert.Pass();
+        else
+            Assert.Fail();
+    }
+
+    [Test]
+    public void GetMessageInbox()
+    {
+        Client.LoginAsync(s_Server, s_LoginName, s_UserName, s_Password).Wait();
+
+        Task<MessagePreview[]> messages = Client.GetMessageInboxAsync();
+        messages.Wait();
+        if (messages.Result.Length > 0)
+            Assert.Pass();
+        else
+            Assert.Fail();
+    }
+
+    [Test]
+    public void GetFullMessage()
+    {
+        Client.LoginAsync(s_Server, s_LoginName, s_UserName, s_Password).Wait();
+
+        Task<MessagePreview[]> messages = Client.GetMessageInboxAsync();
+        messages.Wait();
+        Task<Message> msg = messages.Result.First(msg => msg.Subject == "Test").GetFullMessageAsync(Client);
+        msg.Wait();
+        _ = msg.Result;
+        return;
+    }
+
+    [Test]
+    public void GetReceptionPeople()
+    {
+        Client.LoginAsync(s_Server, s_LoginName, s_UserName, s_Password).Wait();
+
+        Task<Dictionary<string, MessagePerson[]>> people = Client.GetMessagePeopleAsync();
+        people.Wait();
+        if (people.Result.Count > 0)
+            Assert.Pass();
+        else
+            Assert.Fail();
+    }
+
+    [Test]
+    public void GetDrafts()
+    {
+        Client.LoginAsync(s_Server, s_LoginName, s_UserName, s_Password).Wait();
+
+        Task<DraftPreview[]> drafts = Client.GetSavedDraftsAsync();
+        drafts.Wait();
+        if (drafts.Result != null)
+            Assert.Pass();
+        else
+            Assert.Fail();
+    }
+}

README.md

@@ -1,6 +1,6 @@
 # WebUntisAPI.Client
 
-This .NET library allows you to connect you with a WebUntis account and load all of the data you need from there.<br>
+This .NET library allows you to connect you with a WebUntis account and load all of the data you need from there.
 
 ## Download sources:
 - [![GitHub](https://img.shields.io/badge/GitHub-Releases-black)](https://github.com/Suiram1701/WebUntisAPI.Client/releases)
@@ -30,8 +30,8 @@ Remarks:
 - Under no circumstances should 10 req. per sec., more than 1800req. per hr (but in no case more than 3600 req. per hr). If the specifications are exceeded, access to WebUntis could permanently blocked by the WebUntis API.
 
 ### 3. Send requests
-After your login you can send requests to get informations about your timetable and all about.<br>
-The methods an what they do shoud be self-explained.<br>
+After your login you can send requests to get informations about your timetable and all about.
+The methods an what they do shoud be self-explained.
 
 ## Issues
 When you had an error that you don't understand or you don't understand how you can use the library you can create an issue so that I can help you by your problem.

WebUntisAPI.Client/Converter/APIDateTimeJsonConverter.cs

@@ -0,0 +1,21 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+
+namespace WebUntisAPI.Client.Converter
+{
+    internal class APIDateTimeJsonConverter : JsonConverter<DateTime>
+    {
+        public override DateTime ReadJson(JsonReader reader, Type objectType, DateTime existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            JToken token = JToken.Load(reader);
+            return token.Value<DateTime>();
+        }
+
+        public override void WriteJson(JsonWriter writer, DateTime value, JsonSerializer serializer)
+        {
+            string dateTimeString = value.ToString("yyyy-MM-dd") + "T" + value.ToString("HH:mm:ss");
+            writer.WriteValue(dateTimeString);
+        }
+    }
+}

WebUntisAPI.Client/Extensions/DateTimeExtensions.cs

@@ -39,32 +39,25 @@ public static void ToWebUntisTimeFormat(this DateTime dateTime, out string dateS
         ///     The time format is HHMM (Hour Minute).
         ///     </para>
         /// </remarks>
-        /// <param name="dateTime">Instance</param>
+        /// <param name="_">Instance</param>
         /// <param name="dateString">Date string</param>
         /// <param name="timeString">Time string</param>
         /// <returns>The new instance that contains the given time. When not to throw on exception and an exception happened is the return value <see langword="null"/></returns>
         /// <exception cref="FormatException">Thrown when one of the given strings isn't in the right format</exception>
-        public static DateTime FromWebUntisTimeFormat(this DateTime dateTime, string dateString, string timeString)
+        public static DateTime FromWebUntisTimeFormat(this DateTime _, string dateString, string timeString)
         {
-            Regex dateRegex = new Regex(@"^\d{4}(?:0\d|1[0-2])(?:0[1-9]|[1-2]\d|3[0-1])$");     // Regex for the WebUntis date format
-            Regex timeRegex = new Regex(@"^(?:\d|1\d|2[0-3])[0-5]\d$");     // Regex for the WebUntis time format
-
-            // Check if the date- and time strings are valid
-            bool isDateValid = dateRegex.IsMatch(dateString);
-            bool isTimeValid = timeRegex.IsMatch(timeString);
-
-            if (!isDateValid || !isTimeValid)
-                throw new FormatException($"The string {(isDateValid ? timeString : dateString)} isn't in the valid format!");
+            Match dateMatch = Regex.Match(dateString, @"^(\d{4})(0\d|1[0-2])(0[1-9]|[1-2]\d|3[0-1])$");
+            Match timeMatch = Regex.Match(timeString, @"^(\d|1\d|2[0-3])([0-5]\d)$");
 
+            if (!dateMatch.Success || !timeMatch.Success)
+                throw new FormatException("A valid format was expected");
 
-            // Parse the numbers in the string to value
-            int year = int.Parse(dateString.Substring(0, 4));
-            int month = int.Parse(dateString.Substring(4, 2));
-            int day = int.Parse(dateString.Substring(6, 2));
+            int year = int.Parse(dateMatch.Groups[1].Value);
+            int month = int.Parse(dateMatch.Groups[2].Value);
+            int day = int.Parse(dateMatch.Groups[3].Value);
 
-            bool is4Letters = timeString.Length == 4;
-            int hour = int.Parse(is4Letters ? timeString.Substring(0, 2) : timeString[0].ToString());
-            int minute = int.Parse(is4Letters ? timeString.Substring(2, 2) : timeString.Substring(1, 2));
+            int hour = int.Parse(timeMatch.Groups[1].Value);
+            int minute = int.Parse(timeMatch.Groups[2].Value);
 
             // date and time string to DateTime instance
             return new DateTime(year, month, day, hour, minute, 0);

WebUntisAPI.Client/Models/Messages/Attachment.cs

@@ -0,0 +1,88 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace WebUntisAPI.Client.Models.Messages
+{
+    /// <summary>
+    /// An attachment from a message
+    /// </summary>
+    [DebuggerDisplay("{Name, nq}")]
+    public struct Attachment
+    {
+        /// <summary>
+        /// The file name of the attachment
+        /// </summary>
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The attachment id
+        /// </summary>
+        [JsonProperty("id")]
+        internal readonly string _id;
+
+        /// <summary>
+        /// Get the content of the attachment as stream
+        /// </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="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<MemoryStream> DownloadContentAsStreamAsync(WebUntisClient client, int timeout = 2000, CancellationToken ct = default)
+        {
+            string storageResponseString = await client.MakeAPIGetRequestAsync($"/WebUntis/api/rest/view/v1/messages/{_id}/attachmentstorageurl", ct);
+
+            JObject data = JObject.Parse(storageResponseString);
+            JArray headerArray = data.Value<JArray>("additionalHeaders");
+
+            HttpRequestMessage request = new HttpRequestMessage()
+            {
+                Method = HttpMethod.Get,
+                RequestUri = new Uri(data.Value<string>("downloadUrl"))
+            };
+
+            // Auth headers
+            foreach (JObject jsonHeader in headerArray.Cast<JObject>())
+                request.Headers.Add(jsonHeader.Value<string>("key"), jsonHeader.Value<string>("value"));
+
+            // Date header
+            string dateStr = DateTime.Now.ToString("yyyyMMdd");
+            string timeStr = DateTime.Now.ToString("HHmmss");
+            request.Headers.Add("x-amz-date", $"{dateStr}T{timeStr}Z");
+
+            using (HttpClient downloadClient = new HttpClient())
+            {
+                downloadClient.Timeout = TimeSpan.FromMilliseconds(timeout);
+                HttpResponseMessage response = await downloadClient.SendAsync(request, ct);
+
+                // Check cancellation token
+                if (ct.IsCancellationRequested)
+                    return default;
+
+                // Verify response
+                if (response.StatusCode != HttpStatusCode.OK)
+                    throw new HttpRequestException($"There was an error while the http request (Code: {response.StatusCode}).");
+
+                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}");
+                }
+
+                return (MemoryStream)await response.Content.ReadAsStreamAsync();
+            }
+        }
+    }
+}

WebUntisAPI.Client/Models/Messages/Draft.cs

@@ -0,0 +1,103 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using WebUntisAPI.Client.Converter;
+
+namespace WebUntisAPI.Client.Models.Messages
+{
+    /// <summary>
+    /// A draft
+    /// </summary>
+    [DebuggerDisplay("Subject: {Subject, nq}, Sender: {Sender, nq}, Send time: {SentTime, nq}")]
+    public class Draft
+    {
+        /// <summary>
+        /// The id of the message
+        /// </summary>
+        [JsonProperty("id")]
+        public int Id { get; set; }
+
+        /// <summary>
+        /// The subject of the message
+        /// </summary>
+        [JsonProperty("subject")]
+        public string Subject { get; set; }
+
+        /// <summary>
+        /// The sender of the message (only for messages in the inbox)
+        /// </summary>
+        [JsonProperty("sender")]
+        public MessagePerson Sender { get; set; } = null;
+
+        /// <summary>
+        /// Is the message a reply
+        /// </summary>
+        [JsonProperty("isReply")]
+        public bool IsReply { get; set; }
+
+        /// <summary>
+        /// Can you reply the message
+        /// </summary>
+        [JsonProperty("isReplyAllowed")]
+        public bool IsReplyAllowed { get; set; }
+
+        /// <summary>
+        /// The send time of the message
+        /// </summary>
+        [JsonProperty("sentDateTime")]
+        [JsonConverter(typeof(APIDateTimeJsonConverter))]
+        DateTime SentTime { get; set; }
+
+        /// <summary>
+        /// Is allowed to delete the message
+        /// </summary>
+        [JsonProperty("allowMessageDeletion")]
+        public bool AllowMessageDeletion { get; set; }
+
+        /// <summary>
+        /// Idk
+        /// </summary>
+        [JsonProperty("recipientGroups")]
+        public List<object> RecipientGroups { get; set; }
+
+        /// <summary>
+        /// All the recipients for a message (only for self-sends messages)
+        /// </summary>
+        /// <remarks>
+        /// When its <see langword="null"/> is the recipient the current user
+        /// </remarks>
+        [JsonProperty("recipientPersons")]
+        public List<MessagePerson> Recipients { get; set; } = null;
+
+        /// <summary>
+        /// The full content of the draft
+        /// </summary>
+        [JsonProperty("content")]
+        public string Content { get; set; }
+
+        /// <summary>
+        /// The file attachments of the draft
+        /// </summary>
+        [JsonProperty("storageAttachments")]
+        public List<Attachment> Attachments { get; set; } = new List<Attachment>();
+
+        /// <summary>
+        /// The option for the recipient
+        /// </summary>
+        [JsonProperty("recipientOption")]
+        public string RecipientOption { get; set; }
+
+        /// <summary>
+        /// Forbid the reply (you need the permission to do that)
+        /// </summary>
+        [JsonProperty("forbidReply")]
+        public bool ForbidReply { get; set; }
+
+        /// <summary>
+        /// Idk
+        /// </summary>
+        [JsonProperty("copyToStudents")]
+        public bool CopyToStudents { get; set; }
+    }
+}