Change the way how (most) API request are done

fluXis.Game/FluXisGame.cs

@@ -55,6 +55,7 @@ private void load()
     {
         Children = new Drawable[]
         {
+            Fluxel,
             AudioClock,
             Samples,
             NotificationManager,

fluXis.Game/Map/MapStore.cs

@@ -7,8 +7,8 @@
 using fluXis.Game.Database.Maps;
 using fluXis.Game.Graphics.Background;
 using fluXis.Game.Graphics.Background.Cropped;
-using fluXis.Game.Online.API;
 using fluXis.Game.Online.API.Models.Maps;
+using fluXis.Game.Online.API.Requests.Maps;
 using fluXis.Game.Online.Fluxel;
 using fluXis.Game.Overlay.Notifications;
 using fluXis.Game.Overlay.Notifications.Types.Loading;
@@ -202,14 +202,9 @@ public string Export(RealmMapSet set, LoadingNotificationData notification, bool
     [CanBeNull]
     public APIMap LookUpHash(string hash)
     {
-        var req = fluxel.CreateAPIRequest($"/map/hash/{hash}");
-        req.Perform();
-        var json = req.GetResponseString();
-        if (json == null) return null;
-
-        var map = JsonConvert.DeserializeObject<APIResponse<APIMap>>(json);
-
-        return map.Status != 200 ? null : map.Data;
+        var req = new MapHashLookupRequest(hash);
+        req.Perform(fluxel);
+        return req.Response.Status != 200 ? null : req.Response.Data;
     }
 
     public RealmMap CreateNew()

fluXis.Game/Online/API/APIRequest.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+using osu.Framework.IO.Network;
+
+namespace fluXis.Game.Online.API;
+
+public class APIRequest<T> where T : class
+{
+    protected virtual string Path => string.Empty;
+    protected virtual HttpMethod Method => HttpMethod.Get;
+
+    public event Action<APIResponse<T>> Success;
+    public event Action<Exception> Failure;
+    public event Action<long, long> Progress;
+
+    public APIResponse<T> Response { get; private set; }
+
+    private Fluxel.Fluxel fluxel;
+    private APIEndpointConfig config => fluxel.Endpoint;
+
+    public void Perform(Fluxel.Fluxel fluxel)
+    {
+        this.fluxel = fluxel;
+
+        var request = new JsonWebRequest<APIResponse<T>>($"{config.APIUrl}{Path}", Method);
+        request.AllowInsecureRequests = true;
+        request.UploadProgress += (current, total) => Progress?.Invoke(current, total);
+
+        if (!string.IsNullOrEmpty(fluxel.Token))
+            request.AddHeader("Authorization", fluxel.Token);
+
+        try
+        {
+            CreatePostData(request);
+            request.Perform();
+            Response = request.ResponseObject;
+        }
+        catch (Exception e)
+        {
+            Response = new APIResponse<T>(400, e.Message, null);
+            Failure?.Invoke(e);
+        }
+
+        if (Response != null)
+            fluxel.Schedule(() => Success?.Invoke(Response));
+    }
+
+    public Task PerformAsync(Fluxel.Fluxel fluxel)
+    {
+        var task = new Task(() => Perform(fluxel));
+        task.Start();
+        return task;
+    }
+
+    protected virtual void CreatePostData(JsonWebRequest<APIResponse<T>> request) { }
+}

fluXis.Game/Online/API/Requests/Account/DisplayNameUpdateRequest.cs

@@ -0,0 +1,22 @@
+using System.Net.Http;
+using osu.Framework.IO.Network;
+
+namespace fluXis.Game.Online.API.Requests.Account;
+
+public class DisplayNameUpdateRequest : APIRequest<dynamic>
+{
+    protected override string Path => "/account/update/displayname";
+    protected override HttpMethod Method => HttpMethod.Post;
+
+    private string displayName { get; }
+
+    public DisplayNameUpdateRequest(string displayName)
+    {
+        this.displayName = displayName;
+    }
+
+    protected override void CreatePostData(JsonWebRequest<APIResponse<dynamic>> request)
+    {
+        request.AddRaw(displayName);
+    }
+}

fluXis.Game/Online/API/Requests/Account/SocialUpdateRequest.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.Net.Http;
+using Newtonsoft.Json;
+using osu.Framework.IO.Network;
+
+namespace fluXis.Game.Online.API.Requests.Account;
+
+public class SocialUpdateRequest : APIRequest<dynamic>
+{
+    protected override string Path => "/account/update/socials";
+    protected override HttpMethod Method => HttpMethod.Post;
+
+    private string twitter { get; }
+    private string youtube { get; }
+    private string twitch { get; }
+    private string discord { get; }
+
+    public SocialUpdateRequest(string twitter, string youtube, string twitch, string discord)
+    {
+        this.twitter = twitter;
+        this.youtube = youtube;
+        this.twitch = twitch;
+        this.discord = discord;
+    }
+
+    protected override void CreatePostData(JsonWebRequest<APIResponse<dynamic>> request)
+    {
+        request.AddRaw(JsonConvert.SerializeObject(new Dictionary<string, string>
+        {
+            { "twitter", twitter },
+            { "youtube", youtube },
+            { "twitch", twitch },
+            { "discord", discord }
+        }));
+    }
+}

fluXis.Game/Online/API/Requests/MapSets/MapSetsRequest.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+using fluXis.Game.Online.API.Models.Maps;
+
+namespace fluXis.Game.Online.API.Requests.MapSets;
+
+public class MapSetsRequest : APIRequest<List<APIMapSet>>
+{
+    protected override string Path => "/mapsets";
+}

fluXis.Game/Online/API/Requests/Maps/MapHashLookupRequest.cs

@@ -0,0 +1,15 @@
+using fluXis.Game.Online.API.Models.Maps;
+
+namespace fluXis.Game.Online.API.Requests.Maps;
+
+public class MapHashLookupRequest : APIRequest<APIMap>
+{
+    protected override string Path => $"/map/hash/{hash}";
+
+    private string hash { get; }
+
+    public MapHashLookupRequest(string hash)
+    {
+        this.hash = hash;
+    }
+}

fluXis.Game/Online/API/Requests/Maps/MapLeaderboardRequest.cs

@@ -0,0 +1,26 @@
+using System;
+using fluXis.Game.Online.API.Models.Scores;
+using fluXis.Game.Screens.Select.Info.Scores;
+
+namespace fluXis.Game.Online.API.Requests.Maps;
+
+public class MapLeaderboardRequest : APIRequest<APIScores>
+{
+    protected override string Path => type switch
+    {
+        ScoreListType.Global => $"/map/{id}/scores",
+        ScoreListType.Country => $"/map/{id}/scores/country",
+        ScoreListType.Friends => $"/map/{id}/scores/friends",
+        ScoreListType.Club => $"/map/{id}/scores/club",
+        _ => throw new ArgumentOutOfRangeException()
+    };
+
+    private ScoreListType type { get; }
+    private int id { get; }
+
+    public MapLeaderboardRequest(ScoreListType type, int id)
+    {
+        this.type = type;
+        this.id = id;
+    }
+}

fluXis.Game/Online/API/Requests/Maps/MapSetUploadRequest.cs

@@ -0,0 +1,26 @@
+using System.Net.Http;
+using fluXis.Game.Database.Maps;
+using fluXis.Game.Online.API.Models.Maps;
+using osu.Framework.IO.Network;
+
+namespace fluXis.Game.Online.API.Requests.Maps;
+
+public class MapSetUploadRequest : APIRequest<APIMapSet>
+{
+    protected override string Path => map.OnlineID != -1 ? $"/map/{map.OnlineID}/update" : "/maps";
+    protected override HttpMethod Method => HttpMethod.Post;
+
+    private byte[] file { get; }
+    private RealmMapSet map { get; }
+
+    public MapSetUploadRequest(byte[] file, RealmMapSet map)
+    {
+        this.file = file;
+        this.map = map;
+    }
+
+    protected override void CreatePostData(JsonWebRequest<APIResponse<APIMapSet>> request)
+    {
+        request.AddFile("file", file);
+    }
+}

fluXis.Game/Online/API/Requests/Scores/ScoreSubmitRequest.cs

@@ -0,0 +1,39 @@
+using System.Net.Http;
+using fluXis.Game.Online.API.Models.Scores;
+using fluXis.Game.Scoring;
+using Newtonsoft.Json;
+using osu.Framework.IO.Network;
+
+namespace fluXis.Game.Online.API.Requests.Scores;
+
+public class ScoreSubmitRequest : APIRequest<APIScoreResponse>
+{
+    protected override string Path => "/scores/upload";
+    protected override HttpMethod Method => HttpMethod.Post;
+
+    private ScoreInfo score { get; }
+    private float scrollspeed { get; }
+
+    public ScoreSubmitRequest(ScoreInfo score, float scrollspeed)
+    {
+        this.score = score;
+        this.scrollspeed = scrollspeed;
+    }
+
+    protected override void CreatePostData(JsonWebRequest<APIResponse<APIScoreResponse>> request)
+    {
+        request.AddRaw(JsonConvert.SerializeObject(new
+        {
+            hash = score.MapHash,
+            mods = score.Mods,
+            scrollSpeed = scrollspeed,
+            maxCombo = score.MaxCombo,
+            flawless = score.Flawless,
+            perfect = score.Perfect,
+            great = score.Great,
+            alright = score.Alright,
+            okay = score.Okay,
+            miss = score.Miss
+        }));
+    }
+}

fluXis.Game/Online/API/Requests/Users/OnlineUsersRequest.cs

@@ -0,0 +1,8 @@
+using fluXis.Game.Online.API.Models.Users;
+
+namespace fluXis.Game.Online.API.Requests.Users;
+
+public class OnlineUsersRequest : APIRequest<APIOnlineUsers>
+{
+    protected override string Path => "/users/online";
+}

fluXis.Game/Online/Fluxel/Fluxel.cs

@@ -355,6 +355,8 @@ public WebRequest CreateAPIRequest(string url, HttpMethod method = null)
         return request;
     }
 
+    internal new void Schedule(Action action) => base.Schedule(action);
+
     private void onAuthResponse(FluxelResponse<string> response)
     {
         if (response.Status == 200)

fluXis.Game/Online/Scores/OnlineScores.cs

@@ -1,11 +1,10 @@
 using System;
 using System.Linq;
-using System.Net.Http;
 using fluXis.Game.Configuration;
 using fluXis.Game.Online.API;
 using fluXis.Game.Online.API.Models.Scores;
+using fluXis.Game.Online.API.Requests.Scores;
 using fluXis.Game.Scoring;
-using Newtonsoft.Json;
 
 namespace fluXis.Game.Online.Scores;
 
@@ -15,7 +14,7 @@ public static async void UploadScore(Fluxel.Fluxel fluxel, ScoreInfo score, Acti
     {
         if (fluxel.Token == null)
         {
-            callback(new APIResponse<APIScoreResponse>(401, "No token", null));
+            callback(new APIResponse<APIScoreResponse>(401, "Not logged in.", null));
             return;
         }
 
@@ -25,24 +24,8 @@ public static async void UploadScore(Fluxel.Fluxel fluxel, ScoreInfo score, Acti
             return;
         }
 
-        var submitScore = new
-        {
-            hash = score.MapHash,
-            mods = score.Mods,
-            scrollSpeed = fluxel.Config.Get<float>(FluXisSetting.ScrollSpeed),
-            maxCombo = score.MaxCombo,
-            flawless = score.Flawless,
-            perfect = score.Perfect,
-            great = score.Great,
-            alright = score.Alright,
-            okay = score.Okay,
-            miss = score.Miss
-        };
-
-        var req = fluxel.CreateAPIRequest("/scores/upload", HttpMethod.Post);
-        req.AddRaw(JsonConvert.SerializeObject(submitScore));
-        await req.PerformAsync();
-
-        callback(JsonConvert.DeserializeObject<APIResponse<APIScoreResponse>>(req.GetResponseString()));
+        var req = new ScoreSubmitRequest(score, fluxel.Config.Get<float>(FluXisSetting.ScrollSpeed));
+        await req.PerformAsync(fluxel);
+        callback(req.Response);
     }
 }