mirror of
https://github.com/knah/VRCMelonAssistant.git
synced 2024-04-29 10:02:56 +12:00
365 lines
14 KiB
C#
365 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.IO.Compression;
|
|
using System.Net;
|
|
using System.Net.Http.Headers;
|
|
using System.Threading.Tasks;
|
|
using System.Web;
|
|
using System.Windows;
|
|
using static ModAssistant.Http;
|
|
|
|
namespace ModAssistant.API
|
|
{
|
|
public class BeatSaver
|
|
{
|
|
private const string BeatSaverURLPrefix = "https://beatsaver.com";
|
|
private static readonly string CustomSongsFolder = Path.Combine("Beat Saber_Data", "CustomLevels");
|
|
private const bool BypassDownloadCounter = false;
|
|
|
|
public static async Task<BeatSaverMap> GetFromKey(string Key, bool showNotification = true)
|
|
{
|
|
if (showNotification && App.OCIWindow != "No") OneClickInstaller.Status.Show();
|
|
return await GetMap(Key, "key", showNotification);
|
|
}
|
|
|
|
public static async Task<BeatSaverMap> GetFromHash(string Hash, bool showNotification = true)
|
|
{
|
|
if (showNotification && App.OCIWindow != "No") OneClickInstaller.Status.Show();
|
|
return await GetMap(Hash, "hash", showNotification);
|
|
}
|
|
|
|
private static async Task<BeatSaverMap> GetMap(string id, string type, bool showNotification)
|
|
{
|
|
string urlSegment;
|
|
switch (type)
|
|
{
|
|
case "hash":
|
|
urlSegment = "/api/maps/by-hash/";
|
|
break;
|
|
case "key":
|
|
urlSegment = "/api/maps/detail/";
|
|
break;
|
|
default:
|
|
return null;
|
|
}
|
|
|
|
BeatSaverMap map = new BeatSaverMap
|
|
{
|
|
Success = false
|
|
};
|
|
|
|
if (showNotification) Utils.SetMessage($"{string.Format((string)Application.Current.FindResource("OneClick:Installing"), id)}");
|
|
try
|
|
{
|
|
BeatSaverApiResponse beatsaver = await GetResponse(BeatSaverURLPrefix + urlSegment + id);
|
|
if (beatsaver != null && beatsaver.map != null)
|
|
{
|
|
map.response = beatsaver;
|
|
map.Name = await InstallMap(beatsaver.map, showNotification);
|
|
map.Success = true;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
ModAssistant.Utils.Log($"Failed downloading BeatSaver map: {id} | Error: {e.Message}", "ERROR");
|
|
Utils.SetMessage($"{string.Format((string)Application.Current.FindResource("OneClick:Failed"), (map.Name ?? id))}");
|
|
App.CloseWindowOnFinish = false;
|
|
}
|
|
return map;
|
|
}
|
|
|
|
private static async Task<BeatSaverApiResponse> GetResponse(string url, bool showNotification = true, int retries = 3)
|
|
{
|
|
if (retries == 0)
|
|
{
|
|
ModAssistant.Utils.Log($"Max tries reached: Skipping {url}", "ERROR");
|
|
Utils.SetMessage($"{string.Format((string)Application.Current.FindResource("OneClick:RatelimitSkip"), url)}");
|
|
App.CloseWindowOnFinish = false;
|
|
throw new Exception("Max retries allowed");
|
|
}
|
|
|
|
BeatSaverApiResponse response = new BeatSaverApiResponse();
|
|
try
|
|
{
|
|
var resp = await HttpClient.GetAsync(url);
|
|
response.statusCode = resp.StatusCode;
|
|
response.ratelimit = GetRatelimit(resp.Headers);
|
|
string body = await resp.Content.ReadAsStringAsync();
|
|
|
|
if ((int)resp.StatusCode == 429)
|
|
{
|
|
Utils.SetMessage($"{string.Format((string)Application.Current.FindResource("OneClick:RatelimitHit"), response.ratelimit.ResetTime.ToLocalTime())}");
|
|
await response.ratelimit.Wait();
|
|
return await GetResponse(url, showNotification, retries - 1);
|
|
}
|
|
|
|
if (response.statusCode == HttpStatusCode.OK)
|
|
{
|
|
response.map = JsonSerializer.Deserialize<BeatSaverApiResponseMap>(body);
|
|
return response;
|
|
}
|
|
else
|
|
{
|
|
Utils.SetMessage($"{string.Format((string)Application.Current.FindResource("OneClick:Failed"), url)}");
|
|
App.CloseWindowOnFinish = false;
|
|
return response;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (showNotification)
|
|
{
|
|
MessageBox.Show($"{Application.Current.FindResource("OneClick:MapDownloadFailed")}\n\n" + e);
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static async Task<string> InstallMap(BeatSaverApiResponseMap Map, bool showNotification = true)
|
|
{
|
|
string zip = Path.Combine(Utils.BeatSaberPath, CustomSongsFolder, Map.hash) + ".zip";
|
|
string mapName = string.Concat(($"{Map.key} ({Map.metadata.songName} - {Map.metadata.levelAuthorName})")
|
|
.Split(ModAssistant.Utils.Constants.IllegalCharacters));
|
|
string directory = Path.Combine(Utils.BeatSaberPath, CustomSongsFolder, mapName);
|
|
|
|
#pragma warning disable CS0162 // Unreachable code detected
|
|
if (BypassDownloadCounter)
|
|
{
|
|
await Utils.DownloadAsset(BeatSaverURLPrefix + Map.directDownload, CustomSongsFolder, Map.hash + ".zip", mapName, showNotification, true);
|
|
}
|
|
else
|
|
{
|
|
await Utils.DownloadAsset(BeatSaverURLPrefix + Map.downloadURL, CustomSongsFolder, Map.hash + ".zip", mapName, showNotification, true);
|
|
}
|
|
#pragma warning restore CS0162 // Unreachable code detected
|
|
|
|
if (File.Exists(zip))
|
|
{
|
|
string mimeType = MimeMapping.GetMimeMapping(zip);
|
|
|
|
if (!mimeType.StartsWith("application/x-zip"))
|
|
{
|
|
ModAssistant.Utils.Log($"Failed extracting BeatSaver map: {zip} \n| Content: {string.Join("\n", File.ReadAllLines(zip))}", "ERROR");
|
|
throw new Exception("File not a zip.");
|
|
}
|
|
|
|
try
|
|
{
|
|
using (FileStream stream = new FileStream(zip, FileMode.Open))
|
|
using (ZipArchive archive = new ZipArchive(stream))
|
|
{
|
|
foreach (ZipArchiveEntry file in archive.Entries)
|
|
{
|
|
string fileDirectory = Path.GetDirectoryName(Path.Combine(directory, file.FullName));
|
|
if (!Directory.Exists(fileDirectory))
|
|
{
|
|
Directory.CreateDirectory(fileDirectory);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(file.Name))
|
|
{
|
|
file.ExtractToFile(Path.Combine(directory, file.FullName), true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
File.Delete(zip);
|
|
ModAssistant.Utils.Log($"Failed extracting BeatSaver map: {zip} | Error: {e} \n| Content: {string.Join("\n", File.ReadAllLines(zip))}", "ERROR");
|
|
throw new Exception("File extraction failed.");
|
|
}
|
|
File.Delete(zip);
|
|
}
|
|
else
|
|
{
|
|
if (showNotification)
|
|
{
|
|
string line1 = (string)Application.Current.FindResource("OneClick:SongDownload:Failed");
|
|
string line2 = (string)Application.Current.FindResource("OneClick:SongDownload:NetworkIssues");
|
|
string title = (string)Application.Current.FindResource("OneClick:SongDownload:FailedTitle");
|
|
MessageBox.Show($"{line1}\n{line2}", title);
|
|
}
|
|
throw new Exception("Zip file not found.");
|
|
}
|
|
return mapName;
|
|
}
|
|
|
|
public static BeatSaverRatelimit GetRatelimit(HttpResponseHeaders headers)
|
|
{
|
|
BeatSaverRatelimit ratelimit = new BeatSaverRatelimit();
|
|
|
|
if (headers.TryGetValues("Rate-Limit-Remaining", out IEnumerable<string> _remaining))
|
|
{
|
|
var Remaining = _remaining.GetEnumerator();
|
|
Remaining.MoveNext();
|
|
ratelimit.Remaining = int.Parse(Remaining.Current);
|
|
Remaining.Dispose();
|
|
}
|
|
|
|
if (headers.TryGetValues("Rate-Limit-Reset", out IEnumerable<string> _reset))
|
|
{
|
|
var Reset = _reset.GetEnumerator();
|
|
Reset.MoveNext();
|
|
ratelimit.Reset = int.Parse(Reset.Current);
|
|
ratelimit.ResetTime = UnixTimestampToDateTime((long)ratelimit.Reset);
|
|
Reset.Dispose();
|
|
}
|
|
|
|
if (headers.TryGetValues("Rate-Limit-Total", out IEnumerable<string> _total))
|
|
{
|
|
var Total = _total.GetEnumerator();
|
|
Total.MoveNext();
|
|
ratelimit.Total = int.Parse(Total.Current);
|
|
Total.Dispose();
|
|
}
|
|
|
|
return ratelimit;
|
|
}
|
|
|
|
public static DateTime UnixTimestampToDateTime(double unixTime)
|
|
{
|
|
DateTime unixStart = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
|
|
long unixTimeStampInTicks = (long)(unixTime * TimeSpan.TicksPerSecond);
|
|
return new DateTime(unixStart.Ticks + unixTimeStampInTicks, DateTimeKind.Utc);
|
|
}
|
|
|
|
public static async Task Download(string url, string output, int retries = 3)
|
|
{
|
|
if (retries == 0)
|
|
{
|
|
Utils.SetMessage($"{string.Format((string)Application.Current.FindResource("OneClick:RatelimitSkip"), url)}");
|
|
App.CloseWindowOnFinish = false;
|
|
ModAssistant.Utils.Log($"Max tries reached: Couldn't download {url}", "ERROR");
|
|
throw new Exception("Max retries allowed");
|
|
}
|
|
|
|
var resp = await HttpClient.GetAsync(url);
|
|
|
|
if ((int)resp.StatusCode == 429)
|
|
{
|
|
var ratelimit = GetRatelimit(resp.Headers);
|
|
Utils.SetMessage($"{string.Format((string)Application.Current.FindResource("OneClick:RatelimitHit"), ratelimit.ResetTime.ToLocalTime())}");
|
|
|
|
await ratelimit.Wait();
|
|
await Download(url, output, retries - 1);
|
|
}
|
|
|
|
using (var stream = await resp.Content.ReadAsStreamAsync())
|
|
using (var fs = new FileStream(output, FileMode.OpenOrCreate, FileAccess.Write))
|
|
{
|
|
await stream.CopyToAsync(fs);
|
|
}
|
|
}
|
|
|
|
#pragma warning disable IDE1006 // Naming Styles
|
|
public class BeatSaverMap
|
|
{
|
|
public BeatSaverApiResponse response { get; set; }
|
|
public bool Success { get; set; }
|
|
public string Name { get; set; }
|
|
}
|
|
|
|
public class BeatSaverApiResponse
|
|
{
|
|
public HttpStatusCode statusCode { get; set; }
|
|
public BeatSaverRatelimit ratelimit { get; set; }
|
|
public BeatSaverApiResponseMap map { get; set; }
|
|
}
|
|
|
|
public class BeatSaverRatelimit
|
|
{
|
|
public int? Remaining { get; set; }
|
|
public int? Total { get; set; }
|
|
public int? Reset { get; set; }
|
|
public DateTime ResetTime { get; set; }
|
|
public async Task Wait()
|
|
{
|
|
await Task.Delay(new TimeSpan(Math.Max(ResetTime.Ticks - DateTime.UtcNow.Ticks, 0)));
|
|
}
|
|
}
|
|
|
|
public class BeatSaverApiResponseMap
|
|
{
|
|
public Metadata metadata { get; set; }
|
|
public Stats stats { get; set; }
|
|
public string description { get; set; }
|
|
public DateTime? deletedAt { get; set; }
|
|
public string _id { get; set; }
|
|
public string key { get; set; }
|
|
public string name { get; set; }
|
|
public Uploader uploader { get; set; }
|
|
public DateTime uploaded { get; set; }
|
|
public string hash { get; set; }
|
|
public string directDownload { get; set; }
|
|
public string downloadURL { get; set; }
|
|
public string coverURL { get; set; }
|
|
|
|
public class Difficulties
|
|
{
|
|
public bool easy { get; set; }
|
|
public bool normal { get; set; }
|
|
public bool hard { get; set; }
|
|
public bool expert { get; set; }
|
|
public bool expertPlus { get; set; }
|
|
}
|
|
|
|
public class Metadata
|
|
{
|
|
public Difficulties difficulties { get; set; }
|
|
public Characteristic[] characteristics { get; set; }
|
|
public double duration { get; set; }
|
|
public string songName { get; set; }
|
|
public string songSubName { get; set; }
|
|
public string songAuthorName { get; set; }
|
|
public string levelAuthorName { get; set; }
|
|
public double bpm { get; set; }
|
|
}
|
|
|
|
public class Characteristic
|
|
{
|
|
public string name { get; set; }
|
|
public CharacteristicDifficulties difficulties { get; set; }
|
|
}
|
|
|
|
public class CharacteristicDifficulties
|
|
{
|
|
public Difficulty easy { get; set; }
|
|
public Difficulty normal { get; set; }
|
|
public Difficulty hard { get; set; }
|
|
public Difficulty expert { get; set; }
|
|
public Difficulty expertPlus { get; set; }
|
|
}
|
|
|
|
public class Difficulty
|
|
{
|
|
public double? duration { get; set; }
|
|
public double? length { get; set; }
|
|
public double bombs { get; set; }
|
|
public double notes { get; set; }
|
|
public double obstacles { get; set; }
|
|
public double njs { get; set; }
|
|
public double njsOffset { get; set; }
|
|
}
|
|
|
|
public class Stats
|
|
{
|
|
public int downloads { get; set; }
|
|
public int plays { get; set; }
|
|
public int downVotes { get; set; }
|
|
public int upVotes { get; set; }
|
|
public double heat { get; set; }
|
|
public double rating { get; set; }
|
|
}
|
|
|
|
public class Uploader
|
|
{
|
|
public string _id { get; set; }
|
|
public string username { get; set; }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#pragma warning restore IDE1006 // Naming Styles
|