Add send, revoke and delete method for messages

Suiram1701 · Suiram1701 · commit 1202f9566127 · 2023-07-02T16:14:07.000+02:00
diff --git a/WebUntisAPI.Client/Models/Messages/Attachment.cs b/WebUntisAPI.Client/Models/Messages/Attachment.cs
@@ -31,7 +31,7 @@ public struct Attachment
         /// The attachment id
         /// </summary>
         [JsonProperty("id")]
-        public string Id { get; set; }
+        internal readonly string _id;
 
         /// <summary>
         /// Get the content of the attachment as stream
@@ -45,7 +45,7 @@ public struct Attachment
         /// <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);
+            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");
diff --git a/WebUntisAPI.Client/Models/Messages/Draft.cs b/WebUntisAPI.Client/Models/Messages/Draft.cs
@@ -83,7 +83,7 @@ public class Draft
         /// The file attachments of the draft
         /// </summary>
         [JsonProperty("storageAttachments")]
-        public List<Attachment> Attachments { get; set; }
+        public List<Attachment> Attachments { get; set; } = new List<Attachment>();
 
         /// <summary>
         /// The option for the recipient
@@ -92,7 +92,7 @@ public class Draft
         public string RecipientOption { get; set; }
 
         /// <summary>
-        /// Forbid the reply (you need the permission)
+        /// Forbid the reply (you need the permission to do that)
         /// </summary>
         [JsonProperty("forbidReply")]
         public bool ForbidReply { get; set; }
diff --git a/WebUntisAPI.Client/Models/Messages/Message.cs b/WebUntisAPI.Client/Models/Messages/Message.cs
@@ -90,7 +90,7 @@ public class Message
         /// The file attachments of the message
         /// </summary>
         [JsonProperty("storageAttachments")]
-        public List<Attachment> Attachments { get; set; }
+        public List<Attachment> Attachments { get; set; } = new List<Attachment>();
 
         /// <summary>
         /// Is this a report message
diff --git a/WebUntisAPI.Client/Models/Messages/MessagePerson.cs b/WebUntisAPI.Client/Models/Messages/MessagePerson.cs
@@ -42,8 +42,9 @@ public class MessagePerson
         public Uri ImageUrl { get; set; } = null;
 
         /// <summary>
-        /// The user id of the user
+        /// The id of the user
         /// </summary>
-        public int UserId { get; set; }
+        [JsonProperty("userId")]
+        public int Id { get; set; }
     }
 }
diff --git a/WebUntisAPI.Client/Models/NewsMessage.cs b/WebUntisAPI.Client/Models/NewsMessage.cs
@@ -20,7 +20,7 @@ public class NewsMessage
         public string Subject { get; set; }
 
         /// <summary>
-        /// The normal text of the news in HTML
+        /// The normal text of the news (<![CDATA[<br>]]> is used for line breaks)
         /// </summary>
         [JsonProperty("text")]
         public string Text { get; set; }
diff --git a/WebUntisAPI.Client/WebUntisClient.Messages.cs b/WebUntisAPI.Client/WebUntisClient.Messages.cs
@@ -11,7 +11,6 @@
 using System.Net.Http.Headers;
 using System.Net;
 using System.IO;
-using System.Runtime.InteropServices;
 
 namespace WebUntisAPI.Client
 {
@@ -81,6 +80,205 @@ public async Task<MessagePreview[]> GetMessageInboxAsync(CancellationToken ct =
             return new JsonSerializer().Deserialize<List<MessagePreview>>(jsonMsg.CreateReader()).ToArray();
         }
 
+        /// <summary>
+        /// Send a draft
+        /// </summary>
+        /// <param name="draft">The draft that you want to send</param>
+        /// <param name="recipients">The recipients for the message</param>
+        /// <param name="timeout">The time out for the attachment download (when the draft had attachments they must be downloaded to send them)</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns>The preview of the sent message</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<MessagePreview> SendMessageAsync(Draft draft, MessagePerson[] recipients, int timeout = 2000, CancellationToken ct = default)
+        {
+            Tuple<string, MemoryStream>[] attachments = new Tuple<string, MemoryStream>[0];
+            if (draft.Attachments.Count > 0)
+            {
+                Dictionary<string, Task<MemoryStream>> attachmentTasks = new Dictionary<string, Task<MemoryStream>>();
+
+                foreach (Attachment attachment in draft.Attachments)
+                    attachmentTasks.Add(attachment.Name, attachment.DownloadContentAsStreamAsync(this, timeout, ct));
+
+                await Task.WhenAll(attachmentTasks.Values);
+                attachments = attachmentTasks.Select(attachment => new Tuple<string, MemoryStream>(attachment.Key, attachment.Value.Result)).ToArray();
+            }
+
+            return await SendMessageAsync(draft.Subject, draft.Content, recipients, draft.ForbidReply, attachments, ct);
+        }
+
+        /// <summary>
+        /// Send a message
+        /// </summary>
+        /// <param name="subject">The subject</param>
+        /// <param name="content">The content (use <![CDATA[<br>]]> for line breaks</param>
+        /// <param name="recipients">The recipients for the message</param>
+        /// <param name="forbidReply">Is a reply forbidden (it need a permission to to that)</param>
+        /// <param name="attachments">The attachments to send (Item1 is the name and Item2 the content)</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <returns>The preview of the sent message</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<MessagePreview> SendMessageAsync(string subject, string content, MessagePerson[] recipients, bool forbidReply, Tuple<string, MemoryStream>[] attachments = null, CancellationToken ct = default)
+        {
+            // Check for disposing
+            if (_disposedValue)
+                throw new ObjectDisposedException(GetType().FullName);
+
+            // Check if you logged in
+            if (!LoggedIn)
+                throw new UnauthorizedAccessException("You're not logged in");
+
+            MultipartFormDataContent requestContent = new MultipartFormDataContent();
+
+            // Json part
+            StringWriter sw = new StringWriter();
+            using (JsonWriter writer = new JsonTextWriter(sw))
+            {
+                writer.WriteStartObject();
+
+                writer.WritePropertyName("subject");
+                writer.WriteValue(subject);
+
+                writer.WritePropertyName("content");
+                writer.WriteValue(content);
+
+                writer.WritePropertyName("requestConfirmation");
+                writer.WriteValue(false);
+
+                writer.WritePropertyName("recipientUserIds");
+                writer.WriteStartArray();
+                foreach (MessagePerson recipient in recipients)
+                    writer.WriteValue(recipient.Id);
+                writer.WriteEndArray();
+
+                writer.WritePropertyName("oneDriveAttachments");
+                writer.WriteStartArray();
+                writer.WriteEndArray();
+
+                writer.WritePropertyName("forbidReply");
+                writer.WriteValue(forbidReply);
+
+                writer.WriteEndObject();
+
+                StringContent jsonContent = new StringContent(sw.GetStringBuilder().ToString(), Encoding.UTF8, "application/json");
+                requestContent.Add(jsonContent, "request", "blob");
+            }
+
+            // Attachment part
+            foreach (Tuple<string, MemoryStream> attachment in attachments)
+            {
+                ByteArrayContent fileContent = new ByteArrayContent(attachment.Item2.ToArray());
+                fileContent.Headers.Add("Content-Type", "application/x-msdownload");
+                requestContent.Add(fileContent, "attachments", attachment.Item1);
+            }
+
+            HttpRequestMessage request = new HttpRequestMessage()
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri(ServerUrl + "/WebUntis/api/rest/view/v2/messages/users"),
+                Content = requestContent
+            };
+            request.Headers.Add("JSESSIONID", _sessonId);
+            request.Headers.Add("schoolname", _schoolName);
+            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken);
+
+            HttpResponseMessage response = await _client.SendAsync(request, ct);
+
+            // Verify response
+            if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden)
+            {
+                _ = LogoutAsync();
+                throw new UnauthorizedAccessException("You're not logged in");
+            }
+
+            if (response.StatusCode != HttpStatusCode.OK)
+                throw new HttpRequestException($"There was an error while the http request (Code: {response.StatusCode}).");
+
+            return JsonConvert.DeserializeObject<MessagePreview>(await response.Content.ReadAsStringAsync());
+        }
+
+        /// <summary>
+        /// Revoke a message (move back into drafts)(only for self-sent messages!)
+        /// </summary>
+        /// <param name="message">The message to revoke</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <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 RevokeMessageAsync(MessagePreview message, CancellationToken ct = default)
+        {
+            await RevokeMessageAsync(new Message() { Id = message.Id }, ct);
+        }
+
+        /// <summary>
+        /// Revoke a message (move back into drafts)(only for self-sent messages!)
+        /// </summary>
+        /// <param name="message">The message to revoke</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <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 RevokeMessageAsync(Message message, CancellationToken ct = default)
+        {
+            // Check for disposing
+            if (_disposedValue)
+                throw new ObjectDisposedException(GetType().FullName);
+
+            // Check if you logged in
+            if (!LoggedIn)
+                throw new UnauthorizedAccessException("You're not logged in");
+
+            HttpRequestMessage request = new HttpRequestMessage()
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri(ServerUrl + $"/WebUntis/api/rest/view/v1/messages/{message.Id}/revoke"),
+            };
+            request.Headers.Add("JSESSIONID", _sessonId);
+            request.Headers.Add("schoolname", _schoolName);
+            request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _bearerToken);
+
+            HttpResponseMessage response = await _client.SendAsync(request, ct);
+
+            // Verify response
+            if (response.StatusCode == HttpStatusCode.Unauthorized || response.StatusCode == HttpStatusCode.Forbidden)
+            {
+                _ = LogoutAsync();
+                throw new UnauthorizedAccessException("You're not logged in");
+            }
+
+            if (response.StatusCode != HttpStatusCode.OK)
+                throw new HttpRequestException($"There was an error while the http request (Code: {response.StatusCode}).");
+        }
+
+        /// <summary>
+        /// Delete a message
+        /// </summary>
+        /// <param name="message">Message to delete</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <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 DeleteMessageAsync(MessagePreview message, CancellationToken ct = default)
+        {
+            await DeleteDraftAsync(new Draft() { Id = message.Id }, ct);
+        }
+
+        /// <summary>
+        /// Delete a message
+        /// </summary>
+        /// <param name="message">Message to delete</param>
+        /// <param name="ct">Cancellation token</param>
+        /// <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 DeleteMessageAsync(Message message, CancellationToken ct = default)
+        {
+            await DeleteDraftAsync(new Draft() { Id = message.Id }, ct);
+        }
+
         /// <summary>
         /// Get all your saved drafts
         /// </summary>
@@ -111,7 +309,7 @@ public async Task<DraftPreview[]> GetSavedDraftsAsync(CancellationToken ct = def
         /// <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<DraftPreview> CreateDraftAsync(string subject, string content, string recipientOption, bool forbidReply, bool copyToStudent, Tuple<string, MemoryStream>[] attachments, CancellationToken ct = default)
+        public async Task<DraftPreview> CreateDraftAsync(string subject, string content, string recipientOption, bool forbidReply, bool copyToStudent, Tuple<string, MemoryStream>[] attachments = null, CancellationToken ct = default)
         {
             // Check for disposing
             if (_disposedValue)
@@ -197,13 +395,13 @@ public async Task<DraftPreview> CreateDraftAsync(string subject, string content,
         /// <remarks>Change all in the <paramref name="draft"/> excepted the attachments</remarks>
         /// <param name="draft">The draft to update</param>
         /// <param name="newAttachments">The new attachments (Item1 is the file name and Item2 the content)</param>
-        /// <param name="attachmentIdsToDelete">The <see cref="Attachment.Id"/> from the attachment you want to delete</param>
+        /// <param name="attachmentToDelete">The attachments from the draft you want to delete</param>
         /// <param name="ct">Cancellation token</param>
         /// <returns>The preview of the created draft</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<DraftPreview> UpdateDraftAsync(Draft draft, Tuple<string, MemoryStream>[] newAttachments = null, string[] attachmentIdsToDelete = null, CancellationToken ct = default)
+        public async Task<DraftPreview> UpdateDraftAsync(Draft draft, Tuple<string, MemoryStream>[] newAttachments = null, Attachment[] attachmentToDelete = null, CancellationToken ct = default)
         {
             // Check for disposing
             if (_disposedValue)
@@ -242,8 +440,8 @@ public async Task<DraftPreview> UpdateDraftAsync(Draft draft, Tuple<string, Memo
 
                 writer.WritePropertyName("attachmentIdsToDelete");
                 writer.WriteStartArray();
-                foreach (string attachmentId in attachmentIdsToDelete)
-                    writer.WriteValue(attachmentId);
+                foreach (Attachment attachment in attachmentToDelete ?? new Attachment[0])
+                    writer.WriteValue(attachment._id);
                 writer.WriteEndArray();
 
                 writer.WritePropertyName("forbidReply");

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,9 @@ public class MessagePerson`
`42`	`42`	`public Uri ImageUrl { get; set; } = null;`
`43`	`43`
`44`	`44`	`/// <summary>`
`45`		`- /// The user id of the user`
	`45`	`+ /// The id of the user`
`46`	`46`	`/// </summary>`
`47`		`- public int UserId { get; set; }`
	`47`	`+ [JsonProperty("userId")]`
	`48`	`+ public int Id { get; set; }`
`48`	`49`	`}`
`49`	`50`	`}`