Conversion Class

Author: RiisDev

.vs/ScriptBloxAPI/v17/.suo

@@ -1,11 +1,14 @@
 using ScriptBloxAPI.DataTypes;
 using System.Net.Http;
 using ScriptBloxAPI.Backend_Functions;
+using System.Threading.Tasks;
 
 namespace ScriptBloxAPI.Methods
 {
     public class Authorization
     {
+        #region Non Async
+
         /// <summary>
         /// Sends a ping request to the idle endpoint.
         /// </summary>
@@ -48,7 +51,7 @@ public static BoolStatus ChangePassword(string authorization, string oldPassword
 
             return new BoolStatus(response.Content.ReadAsStringAsync().Result.Contains("Password updated!"), response.Content.ReadAsStringAsync().Result);
         }
-
+        
         /// <summary>
         /// Updates the bio of the user.
         /// </summary>
@@ -101,7 +104,7 @@ public static BoolStatus SendPasswordReset(string emailToReset)
 
             return new BoolStatus(response.Content.ReadAsStringAsync().Result.Contains("Password reset link has been sent to your email!"), response.Content.ReadAsStringAsync().Result);
         }
-
+        
         internal static HttpResponseMessage SendRequest(string url, string authorization, string data, bool withAuth = true)
         {
             if (withAuth)
@@ -115,5 +118,121 @@ internal static HttpResponseMessage SendRequest(string url, string authorization
             return response;
         }
 
+        #endregion
+        #region Async Methods
+
+        /// <summary>
+        /// Sends a ping request to the idle endpoint asynchronously.
+        /// </summary>
+        /// <param name="authorization">The authorization token.</param>
+        /// <returns>A Task BoolStatus representing the asynchronous operation, indicating if the request was successful and the response status code.</returns>
+        public static async Task<BoolStatus> PingIdleAsync(string authorization)
+        {
+            MiscFunctions.HttpClient.DefaultRequestHeaders.Add("authorization", authorization);
+            HttpResponseMessage response = await MiscFunctions.HttpClient.GetAsync("https://scriptblox.com/api/ping/idle");
+            MiscFunctions.HttpClient.DefaultRequestHeaders.Remove("authorization");
+
+            return new BoolStatus(response.IsSuccessStatusCode, response.StatusCode.ToString());
+        }
+
+        /// <summary>
+        /// Changes the username of the user asynchronously.
+        /// </summary>
+        /// <param name="authorization">The authorization token.</param>
+        /// <param name="newUsername">The new username.</param>
+        /// <returns>A Task BoolStatus representing the asynchronous operation, indicating if the username change was successful and the response text.</returns>
+        public static async Task<BoolStatus> ChangeUsernameAsync(string authorization, string newUsername)
+        {
+            if (await UserMethods.IsUsernameTakenAsync(newUsername))
+                return new BoolStatus(false, "Username taken.");
+
+            HttpResponseMessage response = await SendRequestAsync("https://scriptblox.com/api/user/update", authorization, $"{{\"username\":\"{newUsername}\"}}");
+
+            return new BoolStatus(response.Content.ReadAsStringAsync().Result.Contains("Password updated!"), response.Content.ReadAsStringAsync().Result);
+        }
+
+
+        /// <summary>
+        /// Changes the password of the user asynchronously.
+        /// </summary>
+        /// <param name="authorization">The authorization token.</param>
+        /// <param name="oldPassword">The old password.</param>
+        /// <param name="newPassword">The new password.</param>
+        /// <returns>A Task BoolStatus representing the asynchronous operation, indicating if the password change was successful and the response text.</returns>
+        public static async Task<BoolStatus> ChangePasswordAsync(string authorization, string oldPassword, string newPassword)
+        {
+            HttpResponseMessage response = await SendRequestAsync("https://scriptblox.com/api/user/change-password", authorization, $"{{\"oldPassword\":\"{oldPassword}\",\"newPassword\":\"{newPassword}\"}}");
+
+            return new BoolStatus(response.Content.ReadAsStringAsync().Result.Contains("Password updated!"), response.Content.ReadAsStringAsync().Result);
+        }
+
+        /// <summary>
+        /// Updates the bio of the user asynchronously.
+        /// </summary>
+        /// <param name="authorization">The authorization token.</param>
+        /// <param name="newBio">The new bio.</param>
+        /// <returns>A Task BoolStatus representing the asynchronous operation, indicating if the bio update was successful and the response text.</returns>
+        public static async Task<BoolStatus> UpdateBioAsync(string authorization, string newBio)
+        {
+            HttpResponseMessage response = await SendRequestAsync("https://scriptblox.com/api/user/update", authorization, $"{{\"bio\":\"{newBio}\"}}");
+
+            return new BoolStatus(response.Content.ReadAsStringAsync().Result.Contains("User updated!"), response.Content.ReadAsStringAsync().Result);
+        }
+
+        /// <summary>
+        /// Follows a user on ScriptBlox asynchronously.
+        /// </summary>
+        /// <param name="authorization">The authorization token.</param>
+        /// <param name="username">The username of the user to follow.</param>
+        /// <returns>A Task BoolStatus representing the asynchronous operation, indicating if the follow operation was successful and the response text.</returns>
+        public static async Task<BoolStatus> FollowUserAsync(string authorization, string username)
+        {
+            string userId = await UserMethods.GetUserIdFromNameAsync(username);
+            HttpResponseMessage response = await SendRequestAsync("https://scriptblox.com/api/user/follow", authorization, $"{{\"userId\":\"{userId}\"}}");
+
+            return new BoolStatus(response.Content.ReadAsStringAsync().Result.Contains("You're now following "), response.Content.ReadAsStringAsync().Result);
+        }
+
+
+        /// <summary>
+        /// Unfollows a user on ScriptBlox asynchronously.
+        /// </summary>
+        /// <param name="authorization">The authorization token.</param>
+        /// <param name="username">The username of the user to unfollow.</param>
+        /// <returns>A Task BoolStatus representing the asynchronous operation, indicating if the unfollow operation was successful and the response text.</returns>
+        public static async Task<BoolStatus> UnFollowUserAsync(string authorization, string username)
+        {
+            string userId = await UserMethods.GetUserIdFromNameAsync(username);
+            HttpResponseMessage response = await SendRequestAsync("https://scriptblox.com/api/user/unfollow", authorization, $"{{\"userId\":\"{userId}\"}}");
+
+            return new BoolStatus(response.Content.ReadAsStringAsync().Result.Contains("Unfollowed user "), response.Content.ReadAsStringAsync().Result);
+        }
+
+        /// <summary>
+        /// Sends a password reset request asynchronously.
+        /// </summary>
+        /// <param name="emailToReset">The email address of the user to reset the password for.</param>
+        /// <returns>A Task BoolStatus representing the asynchronous operation, indicating if the password reset request was successful and the response text.</returns>
+        public static async Task<BoolStatus> SendPasswordResetAsync(string emailToReset)
+        {
+            HttpResponseMessage response = await SendRequestAsync("https://scriptblox.com/api/user/reset-password", "", $"{{\"email\":\"{emailToReset}\"}}", false);
+
+            return new BoolStatus(response.Content.ReadAsStringAsync().Result.Contains("Password reset link has been sent to your email!"), response.Content.ReadAsStringAsync().Result);
+        }
+
+        internal static async Task<HttpResponseMessage> SendRequestAsync(string url, string authorization, string data, bool withAuth = true)
+        {
+            if (withAuth)
+                MiscFunctions.HttpClient.DefaultRequestHeaders.Add("authorization", authorization);
+
+            HttpResponseMessage response = await MiscFunctions.HttpClient.PostAsync(url, new StringContent(data));
+
+            if (withAuth)
+                MiscFunctions.HttpClient.DefaultRequestHeaders.Remove("authorization");
+
+            return response;
+        }
+
+        #endregion
     }
 }

Methods/Authorization.cs

@@ -3,11 +3,14 @@
 using System.Collections.Generic;
 using System.Net.Http;
 using ScriptBloxAPI.Backend_Functions;
+using System.Threading.Tasks;
 
 namespace ScriptBloxAPI.Methods
 {
     public class Commenting
     {
+        #region Non Async
+
         /// <summary>
         /// Adds a comment to the specified script using ScriptBlox.
         /// </summary>
@@ -38,8 +41,8 @@ public static CommentObject AddComment(ScriptObject script, string authorization
                 UserMethods.GetUserFromUserId(commentData?.Value<string>("commentBy"))
             );
 
-        }
-
+        }    
+        
         /// <summary>
         /// Deletes a comment with the specified comment ID using the ScriptBlox API.
         /// </summary>
@@ -55,6 +58,7 @@ public static BoolStatus DeleteComment(string authorization, string commentId)
             return new BoolStatus(response.IsSuccessStatusCode, response.Content.ReadAsStringAsync().Result);
         }
 
+        
         /// <summary>
         /// Retrieves the comments associated with a script from ScriptBlox.
         /// </summary>
@@ -89,7 +93,7 @@ public static List<CommentObject> GetCommentsFromScript(ScriptObject script)
 
             return comments;
         }
-
+        
         internal static HttpResponseMessage SendRequest(string url, string authorization, string data, bool withAuth = true)
         {
             if (withAuth)
@@ -102,5 +106,105 @@ internal static HttpResponseMessage SendRequest(string url, string authorization
 
             return response;
         }
+
+        #endregion
+        #region Async
+
+        /// <summary>
+        /// Retrieves the comments associated with a script from ScriptBlox.
+        /// </summary>
+        /// <param name="script">The ScriptObject representing the script.</param>
+        /// <returns>A list of CommentObject representing the comments associated with the script.</returns>
+        /// <exception cref="ScriptBloxException">
+        /// Thrown when an error occurs while fetching the JSON, when the API returns an error message, or when a backend error occurs.
+        /// </exception>
+        public static async Task<List<CommentObject>> GetCommentsFromScriptAsync(ScriptObject script)
+        {
+            List<CommentObject> comments = new List<CommentObject>();
+
+            JToken jsonReturn = JToken.Parse(await MiscFunctions.HttpClient.GetStringAsync($"https://scriptblox.com/api/comment/{script.Id}?page=1&max=999"));
+
+            if (jsonReturn == null)
+                throw new ScriptBloxException("An error has occurred while fetching the JSON, please submit a bug report.");
+            if (jsonReturn["message"] != null)
+                throw new ScriptBloxException(jsonReturn.Value<string>("message"));
+            if (jsonReturn["comments"] == null)
+                throw new ScriptBloxException("Backend error occurred.");
+
+            foreach (JToken comment in jsonReturn["comments"])
+            {
+                comments.Add(new CommentObject(
+                    comment.Value<string>("_id"),
+                    comment.Value<string>("text"),
+                    comment.Value<int>("likeCount"),
+                    comment.Value<int>("dislikeCount"),
+                    await UserMethods.GetUserFromUsernameAsync(comment["commentBy"]?.Value<string>("username"))
+                ));
+            }
+
+            return comments;
+        }
+
+        /// <summary>
+        /// Deletes a comment with the specified comment ID using the ScriptBlox API.
+        /// </summary>
+        /// <param name="authorization">The authorization token.</param>
+        /// <param name="commentId">The ID of the comment to delete.</param>
+        /// <returns>A BoolStatus indicating whether the comment deletion was successful.</returns>
+        public static async Task<BoolStatus> DeleteCommentAsync(string authorization, string commentId)
+        {
+            MiscFunctions.HttpClient.DefaultRequestHeaders.Add("authorization", authorization);
+            HttpResponseMessage response = await MiscFunctions.HttpClient.DeleteAsync($"https://scriptblox.com/api/comment/{commentId}");
+            MiscFunctions.HttpClient.DefaultRequestHeaders.Remove("authorization");
+
+            return new BoolStatus(response.IsSuccessStatusCode, await response.Content.ReadAsStringAsync());
+        }
+
+        /// <summary>
+        /// Adds a comment to the specified script using ScriptBlox.
+        /// </summary>
+        /// <param name="script">The script object to add the comment to.</param>
+        /// <param name="authorization">The authorization token.</param>
+        /// <param name="comment">The text of the comment.</param>
+        /// <returns>The newly added CommentObject.</returns>
+        public static async Task<CommentObject> AddCommentAsync(ScriptObject script, string authorization, string comment)
+        {
+            HttpResponseMessage response = await SendRequestAsync("https://scriptblox.com/api/comment/add", authorization, $"{{\"scriptId\":\"{script.Id}\",\"text\":\"{comment}\"}}");
+
+            JToken jsonReturn = JToken.Parse(await response.Content.ReadAsStringAsync());
+
+            if (jsonReturn == null)
+                throw new ScriptBloxException("An error has occurred while fetching the JSON, please submit a bug report.");
+            if (jsonReturn["message"] == null)
+                throw new ScriptBloxException("An error has occurred while adding comments: message <null>");
+            if (jsonReturn.Value<string>("message") != "Commented!")
+                throw new ScriptBloxException(jsonReturn.Value<string>("message"));
+
+            JToken commentData = jsonReturn["comment"];
+
+            return new CommentObject(
+                commentData?.Value<string>("_id") ?? "-1",
+                commentData?.Value<string>("text") ?? "-1",
+                0,
+                0,
+                await UserMethods.GetUserFromUserIdAsync(commentData?.Value<string>("commentBy"))
+            );
+        }
+
+        internal static async Task<HttpResponseMessage> SendRequestAsync(string url, string authorization, string data, bool withAuth = true)
+        {
+            if (withAuth)
+                MiscFunctions.HttpClient.DefaultRequestHeaders.Add("authorization", authorization);
+
+            HttpResponseMessage response = await MiscFunctions.HttpClient.PostAsync(url, new StringContent(data));
+
+            if (withAuth)
+                MiscFunctions.HttpClient.DefaultRequestHeaders.Remove("authorization");
+
+            return response;
+        }
+
+        #endregion
+        
     }
 }

Methods/Commenting.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Drawing;
+using System.IO;
+using System.Net.Http;
+using System.Text;
+using System.Threading.Tasks;
+using ScriptBloxAPI.Backend_Functions;
+
+namespace ScriptBloxAPI.Methods
+{
+    public class Converter
+    {
+        public static async Task<Bitmap> ConvertWebPToBitmap(string fileUrl)
+        {
+            try
+            {
+                byte[] imageBytes = await MiscFunctions.HttpClient.GetByteArrayAsync(fileUrl);
+                
+                using StringContent imageJsonFormat = new StringContent(
+                    $"{{\"image\": \"{Convert.ToBase64String(imageBytes)}\"}}", Encoding.UTF8, "application/json");
+
+                HttpResponseMessage response =
+                    await MiscFunctions.HttpClient.PostAsync("https://scriptblox.com/api/user/image", imageJsonFormat);
+
+                Bitmap finalBitmap =
+                    new Bitmap(new MemoryStream(Convert.FromBase64String(response.Content.ReadAsStringAsync().Result)));
+
+                return response.IsSuccessStatusCode
+                    ? finalBitmap
+                    : throw new ScriptBloxException(
+                        $"An error occurred while sending the request: {response.Content.ReadAsStringAsync().Result}");
+            }
+            catch (Exception ex)
+            {
+                throw new ScriptBloxException($"An error occurred while trying to handle conversion: {ex}");
+            }
+        }
+    }
+}