1501 lines
66 KiB
C#
1501 lines
66 KiB
C#
using Newtonsoft.Json;
|
|
using Tesses.WebServer;
|
|
//using YouTubeMusicAPI.Models.Info;
|
|
using System.Net.Http.Json;
|
|
using System.Security.Cryptography;
|
|
using System.Collections.Concurrent;
|
|
using System.Web;
|
|
using YoutubeExplode;
|
|
//using YouTubeMusicAPI.Client;
|
|
using YoutubeExplode.Videos;
|
|
using Newtonsoft.Json.Linq;
|
|
using System.ComponentModel;
|
|
using System.Net.Mime;
|
|
using System.Data.Common;
|
|
using System.Text;
|
|
using YoutubeExplode.Search;
|
|
using YouTubeMusicAPI.Client;
|
|
using YouTubeMusicAPI.Models.Search;
|
|
|
|
|
|
|
|
namespace Tesses.YouTubeDownloader2025Companion
|
|
{
|
|
public class Program
|
|
{
|
|
private const string VERSION="1.0.0.0-dev";
|
|
public static async Task InstallExtension()
|
|
{
|
|
var cfg = Config;
|
|
if(cfg is not null)
|
|
{
|
|
object jsonPayload = !string.IsNullOrWhiteSpace(cfg.SSOAppKey) ? new { url = cfg.CompanionUrl, token = cfg.SSOAppKey } : new { url = cfg.CompanionUrl };
|
|
|
|
using HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Put,$"{cfg.TYTDUrl.TrimEnd('/')}/plugin/tytdcompanion/config");
|
|
|
|
msg.Content = JsonContent.Create(jsonPayload);
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session))
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
using(var res = await MyHttpClient.SendAsync(msg))
|
|
{
|
|
if(res.StatusCode == System.Net.HttpStatusCode.NoContent)
|
|
{
|
|
return;
|
|
}
|
|
else if(res.StatusCode == System.Net.HttpStatusCode.NotFound)
|
|
{
|
|
using HttpRequestMessage msg2 = new HttpRequestMessage(HttpMethod.Post,$"{cfg.TYTDUrl.TrimEnd('/')}/package-manage");
|
|
msg2.Content = new System.Net.Http.StringContent($"action=install&name=Tesses.YouTubeDownloader.Plugins.TYTDCompanion&version={VERSION}",new System.Net.Http.Headers.MediaTypeHeaderValue("application/x-www-form-urlencoded"));
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session))
|
|
{
|
|
msg2.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
|
|
}
|
|
|
|
using(var res2 = await MyHttpClient.SendAsync(msg2))
|
|
{
|
|
if(res2.IsSuccessStatusCode)
|
|
{
|
|
using HttpRequestMessage msg3 = new HttpRequestMessage(HttpMethod.Put,$"{cfg.TYTDUrl.TrimEnd('/')}/plugin/tytdcompanion/config");
|
|
|
|
msg3.Content = JsonContent.Create(jsonPayload);
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session))
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
using(var res3 = await MyHttpClient.SendAsync(msg3))
|
|
{
|
|
if(res3.StatusCode == System.Net.HttpStatusCode.NoContent)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
public static void AddVideo(VideoId id, TYTDResolution res = TYTDResolution.LowVideo)
|
|
{
|
|
|
|
EnqueueTask(async()=>{
|
|
var cfg = Config ?? new AuthConfig();
|
|
HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Post,$"{cfg.TYTDUrl.TrimEnd('/')}/api/v1/add");
|
|
|
|
msg.Content = JsonContent.Create(new object[]{new{url=$"https://www.youtube.com/watch?v={id.Value}",res=res.ToString()}});
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session))
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
using(var res = await MyHttpClient.SendAsync(msg))
|
|
{
|
|
if(res.IsSuccessStatusCode)
|
|
Console.WriteLine($"Added video: https://www.youtube.com/watch?v={id.Value}");
|
|
}
|
|
});
|
|
}
|
|
public static void EnqueueTask(Func<Task> task)
|
|
{
|
|
tasks.Enqueue(task);
|
|
}
|
|
static TaskList tasks = new TaskList();
|
|
public static long NowEpoch
|
|
{
|
|
get => DateTimeOffset.UtcNow.ToUnixTimeSeconds();
|
|
}
|
|
|
|
public static SearchResultHandler SearchResultHandler = new SearchResultHandler();
|
|
public static ConcurrentDictionary<string,OneUseTokenData?> OneUse {get;set;}=new ConcurrentDictionary<string,OneUseTokenData?>();
|
|
|
|
public const string AuthConfigPath = "data/Config/auth.json";
|
|
public static object MyLockObject=new object();
|
|
public static AuthConfig? Config =null;
|
|
public static HttpClient MyHttpClient =new HttpClient();
|
|
public static YoutubeClient YouTubeClient = new YoutubeClient();
|
|
|
|
public static YouTubeMusicClient YouTubeMusicClient = new YouTubeMusicClient();
|
|
|
|
|
|
private static long LastRequestMinute = 0;
|
|
private static long RequestsInThisMinute = 0;
|
|
|
|
private const long RequestsPerMinute = 10;
|
|
|
|
private static bool InRateLimit = false;
|
|
|
|
private static bool ShouldRateLimit()
|
|
{
|
|
var curTime = Program.NowEpoch;
|
|
lock(MyLockObject)
|
|
{
|
|
var sec = curTime % 60;
|
|
var minute = (curTime - sec)/60;
|
|
if(LastRequestMinute != minute)
|
|
{
|
|
RequestsInThisMinute = 1;
|
|
LastRequestMinute = minute;
|
|
}
|
|
else
|
|
{
|
|
RequestsInThisMinute++;
|
|
if(RequestsInThisMinute >= RequestsPerMinute)
|
|
{
|
|
InRateLimit = true;
|
|
RequestsInThisMinute = 0;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static async Task RateLimitAsync(Func<Task> task)
|
|
{
|
|
if(InRateLimit || ShouldRateLimit()) await Task.Delay(30000);
|
|
InRateLimit = false;
|
|
await task();
|
|
}
|
|
|
|
public static async Task<T> RateLimitAsync<T>(Func<Task<T>> task)
|
|
{
|
|
if(InRateLimit || ShouldRateLimit()) await Task.Delay(30000);
|
|
InRateLimit = false;
|
|
return await task();
|
|
}
|
|
|
|
public static async IAsyncEnumerable<T> RateLimitAsync<T>(IAsyncEnumerable<T> task)
|
|
{
|
|
await using var enumerator = task.GetAsyncEnumerator();
|
|
while(await RateLimitAsync(async ()=>await enumerator.MoveNextAsync()))
|
|
{
|
|
yield return enumerator.Current;
|
|
}
|
|
}
|
|
public static async Task<T?> MusicBrainzRequestAsync<T>(string url)
|
|
{
|
|
var req = new HttpRequestMessage(HttpMethod.Get,$"https://musicbrainz.org{url}");
|
|
req.Headers.Add("User-Agent","TYTDCompanion/1.0 (tesses@tesses.net)");
|
|
using var resp = await MyHttpClient.SendAsync(req);
|
|
resp.EnsureSuccessStatusCode();
|
|
return await resp.Content.ReadFromJsonAsync<T>();
|
|
}
|
|
|
|
//public static YouTubeMusicClient YouTubeMusicClient = new YouTubeMusicClient();
|
|
|
|
public static async Task RedirectAsync(ServerContext ctx, string url)
|
|
{
|
|
if(ctx.RequestHeaders.GetFirstBoolean("HX-Request"))
|
|
{
|
|
|
|
ctx.ResponseHeaders["HX-Redirect"] = [url];
|
|
await ctx.WithStatusCode(System.Net.HttpStatusCode.NoContent).WriteHeadersAsync();
|
|
}
|
|
else
|
|
{
|
|
|
|
ctx.ResponseHeaders["Location"] = [url];
|
|
await ctx.WithStatusCode(System.Net.HttpStatusCode.SeeOther).WriteHeadersAsync();
|
|
}
|
|
}
|
|
public static async Task AuthRedirectAsync(ServerContext ctx)
|
|
{
|
|
while(true)
|
|
{
|
|
string tmpToken = RandomNumberGenerator.GetHexString(24);
|
|
if(OneUse.TryAdd(tmpToken,null))
|
|
{
|
|
var cfg = Config ?? new AuthConfig();
|
|
await RedirectAsync(ctx,$"{cfg.TYTDUrl.TrimEnd('/')}/sso?app={HttpUtility.UrlEncode(cfg.ServiceName)}&token={HttpUtility.UrlEncode(tmpToken)}");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
public static async Task AuthAsync(ServerContext ctx)
|
|
{
|
|
var json = await ctx.ReadJsonAsync<OneUseTokenData>();
|
|
var cfg = Config ?? new AuthConfig();
|
|
|
|
if(json is not null && json.SSOAppKey == cfg.SSOAppKey && OneUse.TryUpdate(json.Token,json,null))
|
|
{
|
|
ctx.WithStatusCode(System.Net.HttpStatusCode.OK).SendText("OK","text/plain");
|
|
return;
|
|
}
|
|
ctx.StatusCode=401;
|
|
await ctx.SendTextAsync("BAD");
|
|
}
|
|
public static async Task LoginAsync(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirst("token",out var token) && OneUse.TryRemove(token,out var val))
|
|
{
|
|
if(val is not null)
|
|
{
|
|
using(var db = new Database())
|
|
{
|
|
var res = await db.CreateSessionTokenAsync(val.Username);
|
|
ctx.ResponseHeaders["Set-Cookie"]=[$"Session={res.Key}; SameSite=Lax; Expires={DateTimeOffset.FromUnixTimeSeconds(res.Expires).ToString("R")}; HttpOnly"];
|
|
|
|
await RedirectAsync(ctx,"/");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
public static HttpActionAsync EnsureLoggedin(HttpActionAsync action)
|
|
{
|
|
return async(ctx)=>{
|
|
AuthConfig? cfg;
|
|
lock(MyLockObject)
|
|
{
|
|
cfg = Config;
|
|
}
|
|
if(cfg is not null && cfg.Session != "")
|
|
{
|
|
if(ctx.UrlPath == "/oobe")
|
|
{
|
|
await RedirectAsync(ctx,"/");
|
|
return;
|
|
}
|
|
|
|
if(ctx.RequestHeaders.TryGetFirst("Cookie",out var cookie))
|
|
{
|
|
var cookies = cookie.Split("; ", StringSplitOptions.None);
|
|
foreach(var item in cookies)
|
|
{
|
|
var myCookie = item.Split('=',2);
|
|
if(myCookie[0] == "Session")
|
|
{
|
|
using(var db = new Database())
|
|
{
|
|
var session = await db.GetSessionAsync(ctx,myCookie[1]);
|
|
if(session is not null)
|
|
{
|
|
ctx.Tag = session;
|
|
await action(ctx);
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
await AuthRedirectAsync(ctx);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
await AuthRedirectAsync(ctx);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(ctx.UrlPath != "/oobe")
|
|
await RedirectAsync(ctx,"/oobe");
|
|
else
|
|
await action(ctx);
|
|
return;
|
|
}
|
|
};
|
|
}
|
|
public static IEnumerable<PageLink> DefaultLinks()
|
|
{
|
|
yield return new PageLink("Home","home","/");
|
|
yield return new PageLink("Search","search","/search");
|
|
yield return new PageLink("Music","music_note","/music");
|
|
}
|
|
public static void Main(string[] args)
|
|
{
|
|
Directory.CreateDirectory("data/Config");
|
|
using(var myDb =new Database()) myDb.Init();
|
|
Directory.CreateDirectory("data/Music");
|
|
Directory.CreateDirectory("data/Temp");
|
|
Directory.CreateDirectory("data/MusicFromTYTD");
|
|
|
|
Directory.CreateDirectory("data/Thumbnails/Video");
|
|
Directory.CreateDirectory("data/Thumbnails/Albums");
|
|
Directory.CreateDirectory("data/Thumbnails/Artists");
|
|
if(File.Exists(AuthConfigPath))
|
|
{
|
|
Config = JsonConvert.DeserializeObject<AuthConfig>(File.ReadAllText(AuthConfigPath));
|
|
}
|
|
|
|
RouteServer routeServer=new RouteServer(new StaticServer("wwwroot"));
|
|
routeServer.Add("/api/v1/webhook",async(ctx)=>{
|
|
string auth = "";
|
|
ctx.RequestHeaders.TryGetFirst("Authorization",out auth);
|
|
|
|
var authHdr = auth.Split(' ',2,StringSplitOptions.RemoveEmptyEntries);
|
|
var cfg = Config ?? new AuthConfig();
|
|
|
|
if(string.IsNullOrWhiteSpace(cfg.Session) || (authHdr.Length == 2 && authHdr[0] == "TYTD" && cfg.SSOAppKey == authHdr[1]))
|
|
{
|
|
try {
|
|
var webhook = await ctx.ReadJsonAsync<Webhook>();
|
|
if(webhook is not null)
|
|
{
|
|
var epoch = NowEpoch;
|
|
using(var db = new Database())
|
|
await db.AddEventAsync(epoch, webhook);
|
|
Console.WriteLine(JsonConvert.SerializeObject(webhook));
|
|
switch(webhook.Type)
|
|
{
|
|
case "VideoFinished":
|
|
{
|
|
|
|
var vid = VideoId.TryParse(webhook.Video.VideoId);
|
|
EnqueueTask(async()=>{
|
|
if(vid.HasValue)
|
|
await ProcessSongAsync(vid.Value);
|
|
});
|
|
}
|
|
break;
|
|
case "Started":
|
|
{
|
|
EnqueueTask(async()=>{
|
|
using(var db = new Database())
|
|
{
|
|
foreach(var item in await db.GetSongVideosAsync())
|
|
{
|
|
var vid = VideoId.TryParse(item.VideoId);
|
|
if(vid.HasValue)
|
|
await ProcessSongAsync(vid.Value);
|
|
}
|
|
}
|
|
});
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
} catch(Exception ex)
|
|
{
|
|
Console.WriteLine(ex);
|
|
}
|
|
}
|
|
ctx.StatusCode = 204;
|
|
await ctx.WriteHeadersAsync();
|
|
},"POST");
|
|
routeServer.Add("/log",EnsureLoggedin(async (ctx)=>await ctx.SendTextAsync(await Pages.LogAsync(ctx))));
|
|
routeServer.Add("/settings",EnsureLoggedin(SettingsAsync));
|
|
routeServer.Add("/auth",AuthAsync,"POST");
|
|
routeServer.Add("/login",LoginAsync);
|
|
routeServer.Add("/rescan",EnsureLoggedin(async(ctx)=>{
|
|
ctx.ParseBody();
|
|
EnqueueTask(async()=>{
|
|
using(var db = new Database())
|
|
{
|
|
foreach(var item in await db.GetSongVideosAsync())
|
|
{
|
|
var vid = VideoId.TryParse(item.VideoId);
|
|
if(vid.HasValue)
|
|
await ProcessSongAsync(vid.Value);
|
|
}
|
|
}
|
|
});
|
|
await ctx.WithStatusCode(System.Net.HttpStatusCode.ExpectationFailed).WriteHeadersAsync();
|
|
}),"POST");
|
|
routeServer.Add("/",EnsureLoggedin(async(ctx)=>{
|
|
var cfg = Config ?? new AuthConfig();
|
|
await ctx.SendTextAsync(Components.Shell("Home",(await File.ReadAllTextAsync("wwwroot/index.html")).Replace("@TYTD_URL@",HttpUtility.HtmlAttributeEncode($"{cfg.TYTDUrl.TrimEnd('/')}/")),DefaultLinks()));
|
|
|
|
}));
|
|
routeServer.Add("/oobe",EnsureLoggedin(async(ctx)=>{
|
|
await ctx.SendTextAsync(Components.Shell("Setup",await File.ReadAllTextAsync("wwwroot/pages/oobe.html"),[]));
|
|
}));
|
|
routeServer.Add("/oobe",EnsureLoggedin(async(ctx)=>{
|
|
ctx.ParseBody();
|
|
if(ctx.QueryParams.TryGetFirst("companion",out var companion) && ctx.QueryParams.TryGetFirst("tytd",out var tytd) && ctx.QueryParams.TryGetFirst("user",out var user) && ctx.QueryParams.TryGetFirst("pass",out var pass))
|
|
{
|
|
using var resp = await MyHttpClient.PostAsync($"{tytd.TrimEnd('/')}/api/v1/login",JsonContent.Create(new {
|
|
username = user,
|
|
password = pass
|
|
}));
|
|
if(resp.IsSuccessStatusCode)
|
|
{
|
|
var tytdLogin =await resp.Content.ReadFromJsonAsync<TYTDLoginResponse>();
|
|
if(tytdLogin is not null && tytdLogin.Success)
|
|
{
|
|
for(int i = 0; i < 10; i++)
|
|
{
|
|
var service_name_unique = RandomNumberGenerator.GetHexString(24);
|
|
var sso_app_key = RandomNumberGenerator.GetHexString(64);
|
|
var register_req = JsonContent.Create(new{
|
|
service_name = $"tytdcompanion-{service_name_unique}",
|
|
sso_app_key,
|
|
service_pretty_name = "TYTD Companion",
|
|
service_auth_post = $"{companion.TrimEnd('/')}/auth",
|
|
service_auth_redirect = $"{companion.TrimEnd('/')}/login?token="
|
|
});
|
|
var sso_req=new HttpRequestMessage(HttpMethod.Post,$"{tytd.TrimEnd('/')}/api/v1/register_sso");
|
|
sso_req.Content = register_req;
|
|
sso_req.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",tytdLogin.Token);
|
|
using var sso_resp = await MyHttpClient.SendAsync(sso_req);
|
|
var sso_resp2 = JsonConvert.DeserializeObject<SSOResp>(await sso_resp.Content.ReadAsStringAsync());
|
|
if(sso_resp2 is not null)
|
|
{
|
|
if(sso_resp2.Success)
|
|
{
|
|
AuthConfig cfg=new AuthConfig();
|
|
cfg.CompanionUrl = companion;
|
|
cfg.TYTDUrl = tytd;
|
|
cfg.Session = tytdLogin.Token;
|
|
cfg.ServiceName = $"tytdcompanion-{service_name_unique}";
|
|
cfg.SSOAppKey = sso_app_key;
|
|
|
|
File.WriteAllText(AuthConfigPath,JsonConvert.SerializeObject(cfg));
|
|
lock(MyLockObject)
|
|
{
|
|
Config = cfg;
|
|
}
|
|
await InstallExtension();
|
|
await RedirectAsync(ctx,"/");
|
|
return;
|
|
} else if(sso_resp2.Type != "db")
|
|
{
|
|
throw new Exception($"Error of {sso_resp2.Type}, {sso_resp2.Reason}");
|
|
}
|
|
}
|
|
}
|
|
|
|
//MyHttpClient.SendAsync()
|
|
}
|
|
}
|
|
}
|
|
}),"POST");
|
|
routeServer.Add("/search",EnsureLoggedin(Search));
|
|
routeServer.Add("/search_dialog",EnsureLoggedin(SearchDialog));
|
|
routeServer.Add("/search_button",EnsureLoggedin(async(ctx)=>{
|
|
|
|
ctx.ParseBody();
|
|
if(ctx.QueryParams.TryGetFirst("type",out var type))
|
|
{
|
|
if(type == "add" && ctx.QueryParams.TryGetFirst("value",out var value))
|
|
{
|
|
VideoId? id = VideoId.TryParse(value);
|
|
if(id.HasValue)
|
|
{
|
|
AddVideo(id.Value);
|
|
await ctx.SendTextAsync("""<li>Added</li>""");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
await ctx.SendTextAsync("BAD");
|
|
}),"POST");
|
|
routeServer.Add("/search_more",EnsureLoggedin(SearchMore));
|
|
routeServer.Add("/music",EnsureLoggedin(Music));
|
|
routeServer.Add("/music/artists", EnsureLoggedin(Artists));
|
|
routeServer.Add("/music/myartists", EnsureLoggedin(MyArtists));
|
|
routeServer.Add("/music/fix-song",EnsureLoggedin(FixIncorrectGet));
|
|
routeServer.Add("/music/fix-song",EnsureLoggedin(FixIncorrectPost),"POST");
|
|
|
|
routeServer.Add("/music/artist", EnsureLoggedin(Artist));
|
|
routeServer.Add("/music/myartist", EnsureLoggedin(MyArtist));
|
|
routeServer.Add("/music/albums", EnsureLoggedin(Albums));
|
|
routeServer.Add("/music/myalbums", EnsureLoggedin(MyAlbums));
|
|
routeServer.Add("/music/album", EnsureLoggedin(Album));
|
|
routeServer.Add("/music/myalbum", EnsureLoggedin(MyAlbum));
|
|
routeServer.Add("/music/mysongs", EnsureLoggedin(MySongs));
|
|
routeServer.Add("/music/mysong", EnsureLoggedin(MySong));
|
|
routeServer.Add("/music/album/add",EnsureLoggedin(AddAlbum),"POST");
|
|
routeServer.Add("/api/v1/video-thumbnail",EnsureLoggedin(VideoThumbnail));
|
|
routeServer.Add("/api/v1/artist-thumbnail",EnsureLoggedin(ArtistThumbnail));
|
|
routeServer.Add("/api/v1/album-thumbnail",EnsureLoggedin(AlbumThumbnail));
|
|
routeServer.Add("/api/v1/artists",EnsureLoggedin(ApiArtists));
|
|
routeServer.Add("/api/v1/artist",EnsureLoggedin(ApiArtist));
|
|
routeServer.Add("/api/v1/albums",EnsureLoggedin(ApiAlbums));
|
|
routeServer.Add("/api/v1/album",EnsureLoggedin(ApiAlbum));
|
|
routeServer.Add("/api/v1/song",EnsureLoggedin(ApiSong));
|
|
routeServer.Add("/api/v1/album.zip",EnsureLoggedin(ApiAlbumZip));
|
|
bool finished=false;
|
|
|
|
RegisterEventable(SearchResultHandler);
|
|
RegisterEventable(tasks);
|
|
Task t = Task.Factory.StartNew(async()=>{
|
|
while(!finished)
|
|
{
|
|
foreach(var item in eventables)
|
|
await item.EventAsync();
|
|
}
|
|
});
|
|
Task.Run(async()=>{
|
|
await Task.Delay(10000);
|
|
Console.WriteLine("Wait expired");
|
|
await InstallExtension();
|
|
}).Wait(0);
|
|
routeServer.StartServer(4255);
|
|
finished=true;
|
|
t.Wait();
|
|
}
|
|
|
|
private static async Task ApiAlbumZip(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("albumId",out var albumId))
|
|
{
|
|
using(var db = new Database())
|
|
{
|
|
var album = await db.GetAlbumAsync(albumId.ToString());
|
|
var artist = (await db.GetAlbumArtistsAsync(albumId.ToString())).FirstOrDefault();
|
|
if(album is not null && artist is not null)
|
|
{
|
|
string path = $"data/Music/{ServerContext.FixFileName(artist.ArtistName)}/{ServerContext.FixFileName(album.AlbumName)}";
|
|
if(Directory.Exists(path))
|
|
{
|
|
ctx.WithFileName($"{ServerContext.FixFileName(artist.ArtistName)} - {ServerContext.FixFileName(album.AlbumName)}.zip",false);
|
|
using(var resp = ctx.GetResponseStream())
|
|
{
|
|
await System.IO.Compression.ZipFile.CreateFromDirectoryAsync(path,resp,System.IO.Compression.CompressionLevel.Fastest,true);
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
}
|
|
await ctx.SendNotFoundAsync();
|
|
}
|
|
}
|
|
}
|
|
|
|
private static async Task ApiArtists(ServerContext ctx)
|
|
{
|
|
if(!ctx.QueryParams.TryGetFirst("q",out var q))
|
|
q = "";
|
|
if(!ctx.QueryParams.TryGetFirstInt64("offset",out var offset))
|
|
offset = 0;
|
|
if(!ctx.QueryParams.TryGetFirstInt64("count",out var count))
|
|
count = 20;
|
|
using(var db = new Database())
|
|
await ctx.WithMimeType("application/json").SendJsonAsync((await db.GetArtistsAsync(q,offset,count)).ToList());
|
|
}
|
|
|
|
private static async Task ApiArtist(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("artistId",out var artistId))
|
|
{
|
|
if(!ctx.QueryParams.TryGetFirst("q",out var q))
|
|
q = "";
|
|
|
|
if(!ctx.QueryParams.TryGetFirstInt64("offset",out var offset))
|
|
offset = 0;
|
|
if(!ctx.QueryParams.TryGetFirstInt64("count",out var count))
|
|
count = 20;
|
|
|
|
using(var db = new Database())
|
|
await ctx.WithMimeType("application/json").SendJsonAsync((await db.GetAlbumsFromArtistAsync(artistId.ToString(),q,offset,count)).ToList());
|
|
|
|
}
|
|
}
|
|
private static async Task ApiAlbums(ServerContext ctx)
|
|
{
|
|
if(!ctx.QueryParams.TryGetFirst("q",out var q))
|
|
q = "";
|
|
|
|
if(!ctx.QueryParams.TryGetFirstInt64("offset",out var offset))
|
|
offset = 0;
|
|
if(!ctx.QueryParams.TryGetFirstInt64("count",out var count))
|
|
count = 20;
|
|
|
|
using(var db = new Database())
|
|
await ctx.WithMimeType("application/json").SendJsonAsync((await db.GetAlbumsAsync(q,offset,count)).ToList());
|
|
}
|
|
private static async Task ApiAlbum(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("albumId", out var albumId))
|
|
using(var db = new Database())
|
|
{
|
|
List<object> tracks = new List<object>();
|
|
foreach(var item in await db.GetTracksAsync(albumId.ToString()))
|
|
{
|
|
var artists = await db.GetContributingArtistsAsync(item.SongId);
|
|
tracks.Add(new {
|
|
item.SongId,
|
|
item.SongName,
|
|
item.Track,
|
|
ContributingArtists = artists.ToList()
|
|
});
|
|
}
|
|
|
|
var album = await db.GetAlbumAsync(albumId.ToString());
|
|
var albumArtists = await db.GetAlbumArtistsAsync(albumId.ToString());
|
|
await ctx.WithMimeType("application/json").SendJsonAsync(new {
|
|
Album = album,
|
|
AlbumArtists = albumArtists,
|
|
Tracks = tracks
|
|
});
|
|
|
|
}
|
|
}
|
|
private static async Task ApiSong(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("albumId",out var albumId) && ctx.QueryParams.TryGetFirstGuid("songId",out var songId))
|
|
{
|
|
var inline =ctx.QueryParams.GetFirstBoolean("inline");
|
|
MediaEntry? mId = null;
|
|
using(var db = new Database())
|
|
mId = await db.GetMediaEntryAsync(albumId.ToString(),songId.ToString());
|
|
|
|
if(mId is not null)
|
|
{
|
|
string path = mId.ToString();
|
|
if(File.Exists(path))
|
|
{
|
|
ContentDisposition disposition=new ContentDisposition();
|
|
disposition.FileName = Path.GetFileName(path);
|
|
disposition.Inline = inline;
|
|
disposition.ModificationDate = File.GetLastWriteTime(path);
|
|
disposition.CreationDate = File.GetCreationTime(path);
|
|
ctx.ResponseHeaders["Content-Disposition"] = [disposition.ToString()];
|
|
await ctx.SendFileAsync(path);
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
await ctx.SendNotFoundAsync();
|
|
}
|
|
private static async Task SettingsAsync(ServerContext ctx)
|
|
{
|
|
await ctx.SendTextAsync(Pages.Settings(ctx));
|
|
}
|
|
|
|
private static async Task AddAlbum(ServerContext ctx)
|
|
{
|
|
ctx.ParseBody();
|
|
if(ctx.QueryParams.TryGetFirstGuid("id",out var id))
|
|
{
|
|
EnqueueTask(async()=>{
|
|
await AddAlbumAsync(id,true);
|
|
});
|
|
await ctx.SendTextAsync("<span>Added</span>");
|
|
}
|
|
|
|
}
|
|
public static async Task AddArtistAsync(AlbumSongQuery.AlbumSongQueryMedia.AlbumSongQueryMediaTrack.AlbumSongQueryMediaTrackRecording.AlbumSongQueryMediaTrackRecordingArtists artist)
|
|
{
|
|
await RateLimitAsync(async()=>await EnsureArtistThumbnail(artist.Artist.Id));
|
|
|
|
using(var db=new Database())
|
|
await db.AddArtistAsync(new YouTubeDownloader2025Companion.Artist() { ArtistDisambiguation =artist.Artist.Disambiguation , ArtistName = artist.Artist.Name, ArtistId = artist.Artist.Id.ToString() });
|
|
|
|
}
|
|
|
|
public static async Task<VideoId?> GetVideoIdFromSong(AlbumSongQuery.AlbumSongQueryMedia.AlbumSongQueryMediaTrack.AlbumSongQueryMediaTrackRecording recording, string albumName)
|
|
{
|
|
using(var db = new Database())
|
|
{
|
|
VideoId? vid = await db.GetVideoIdAsync(recording.Id.ToString());
|
|
if(vid.HasValue) return vid;
|
|
}
|
|
|
|
string firstArtist = "";
|
|
string name = "";
|
|
foreach(var item in recording.ContributingArtists)
|
|
{
|
|
if(firstArtist.Length == 0) firstArtist = item.Artist.Name;
|
|
name += item.Artist.Name;
|
|
name += item.JoinPhrase;
|
|
}
|
|
|
|
name += $" - \"{albumName}\" - \"{recording.Name}\"";
|
|
|
|
|
|
await foreach(var item in YouTubeMusicClient.SearchAsync(name, YouTubeMusicAPI.Models.Search.SearchCategory.Songs))
|
|
{
|
|
if(item is SongSearchResult ssr)
|
|
{
|
|
string theAlbumName = (ssr.Album?.Name) ?? "";
|
|
VideoId? id;
|
|
if(albumName.Replace(" ","").Equals(theAlbumName.Replace(" ",""), StringComparison.OrdinalIgnoreCase) && recording.Name.Replace(" ","").Equals(ssr.Name.Replace(" ",""), StringComparison.OrdinalIgnoreCase) && (id = VideoId.TryParse(ssr.Id)).HasValue)
|
|
{
|
|
var video = await RateLimitAsync(async()=>await YouTubeClient.Videos.GetAsync(id.Value));
|
|
Console.WriteLine($"Added: {video.Title} with id: {video.Url}, Channel: {video.Author.ChannelTitle}");
|
|
|
|
using(var db = new Database())
|
|
await db.AddVideoIdAsync(recording.Id.ToString(), video.Id, video.Title);
|
|
|
|
return video.Id;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/* await foreach(var item in RateLimitAsync(YouTubeClient.Search.GetResultBatchesAsync(name,YoutubeExplode.Search.SearchFilter.Video)))
|
|
{
|
|
foreach(var vid in item.Items)
|
|
{
|
|
if(vid is VideoSearchResult r)
|
|
{
|
|
if(!r.Author.ChannelTitle.EndsWith("Topic", StringComparison.OrdinalIgnoreCase)) continue;
|
|
if(!r.Title.Contains(recording.Name,StringComparison.OrdinalIgnoreCase)) continue;
|
|
|
|
|
|
Console.WriteLine($"Added: {vid.Title} with id: {vid.Url}, Channel: {r.Author.ChannelTitle}");
|
|
|
|
using(var db = new Database())
|
|
await db.AddVideoIdAsync(recording.Id.ToString(),vid.Url, vid.Title);
|
|
return vid.Url;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}*/
|
|
return null;
|
|
}
|
|
|
|
public static async Task AddAlbumAsync(Guid id,bool addTracks=false)
|
|
{
|
|
await RateLimitAsync(async()=>await EnsureAlbumThumbnail(id));
|
|
var results = await RateLimitAsync(async()=>await MusicBrainzRequestAsync<AlbumSongQuery>($"/ws/2/release/{HttpUtility.UrlEncode(id.ToString())}/?inc=recordings+artist-credits&fmt=json"));
|
|
if(results is not null)
|
|
{
|
|
using(var db=new Database())
|
|
await db.AddAlbumAsync(new YouTubeDownloader2025Companion.Album() { AlbumId = id.ToString(), AlbumName = results.Title, AlbumReleaseDate = results.Date });
|
|
|
|
foreach(var artist in results.Artists)
|
|
{
|
|
using(var db=new Database())
|
|
await db.AddAlbumArtistAsync(id.ToString(), artist.Artist.Id.ToString());
|
|
await AddArtistAsync(artist);
|
|
}
|
|
|
|
if(addTracks)
|
|
{
|
|
foreach(var media in results.Media)
|
|
{
|
|
foreach(var track in media.Tracks)
|
|
{
|
|
|
|
foreach(var artist in track.Recording.ContributingArtists)
|
|
{
|
|
using(var db=new Database())
|
|
await db.AddContributingArtistAsync(track.Recording.Id.ToString(), artist.Artist.Id.ToString());
|
|
await AddArtistAsync(artist);
|
|
|
|
}
|
|
using(var db=new Database())
|
|
{
|
|
await db.AddSongAsync(new Song() { SongId = track.Recording.Id.ToString(), SongName = track.Recording.Name });
|
|
await db.AddTrackAsync(new AlbumTrack() { AlbumId = id.ToString(), SongId = track.Recording.Id.ToString(), Track = track.Track, Length = track.Length});
|
|
}
|
|
|
|
VideoId? vid = await GetVideoIdFromSong(track.Recording, results.Title);
|
|
if(vid.HasValue)
|
|
await ProcessSongAsync(vid.Value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
private static async Task<bool> VideoExistsOnTYTD(VideoId id, TYTDResolution res)
|
|
{
|
|
var cfg = Config ?? new AuthConfig();
|
|
HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Head,$"{cfg.TYTDUrl.TrimEnd('/')}/api/v1/download?v={id.Value}&res={res}");
|
|
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session))
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
using(var res0 = await MyHttpClient.SendAsync(msg))
|
|
{
|
|
return res0.IsSuccessStatusCode;
|
|
}
|
|
}
|
|
public static async Task DownloadSongFromTYTD(VideoId id)
|
|
{
|
|
|
|
string videoPath = Path.Combine("data","MusicFromTYTD",$"{id.Value}");
|
|
if(!File.Exists(videoPath+".bin"))
|
|
{
|
|
var cfg = Config ?? new AuthConfig();
|
|
HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Get,$"{cfg.TYTDUrl.TrimEnd('/')}/api/v1/download?v={id.Value}&res=AudioOnly");
|
|
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session))
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
|
|
using(var res0 = await MyHttpClient.SendAsync(msg))
|
|
{
|
|
res0.EnsureSuccessStatusCode();
|
|
using(var f = File.Create(videoPath+".part"))
|
|
{
|
|
await res0.Content.CopyToAsync(f);
|
|
}
|
|
File.Move(videoPath+".part",videoPath + ".bin");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static async Task ProcessSongAsync(VideoId value)
|
|
{
|
|
string? songId = null;
|
|
using(var db = new Database())
|
|
{
|
|
songId = await db.GetSongIdFromVideoId(value);
|
|
}
|
|
|
|
string videoPath = Path.Combine("data","MusicFromTYTD",$"{value.Value}.bin");
|
|
if(!string.IsNullOrWhiteSpace(songId) && (File.Exists(videoPath) || await VideoExistsOnTYTD(value, TYTDResolution.AudioOnly)))
|
|
{
|
|
await DownloadSongFromTYTD(value);
|
|
|
|
|
|
List<MediaEntry> entries = new List<MediaEntry>();
|
|
|
|
using(var db = new Database())
|
|
{
|
|
|
|
if(!string.IsNullOrWhiteSpace(songId))
|
|
{
|
|
await foreach(var item in db.GetMediaEntriesAsync(songId))
|
|
{
|
|
entries.Add(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if(File.Exists(videoPath))
|
|
{
|
|
foreach(var item in entries)
|
|
{
|
|
await item.ImportAsync(videoPath);
|
|
}
|
|
}
|
|
|
|
} else if(!string.IsNullOrWhiteSpace(songId)) {
|
|
AddVideo(value, TYTDResolution.AudioOnly);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
public static async Task EnsureArtistThumbnail(Guid id)
|
|
{
|
|
string path = $"data/Thumbnails/Artists/{id}.jpg";
|
|
if(!File.Exists(path))
|
|
{
|
|
var cfg = Config ?? new AuthConfig();
|
|
if(cfg.ThumbnailsThroughTYTD)
|
|
{
|
|
HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Get,$"{cfg.TYTDUrl.TrimEnd('/')}/plugin/tytdcompanion/artist-thumbnail?id={id.ToString()}");
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session) && cfg.ThumbnailsThroughTYTD)
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
using(var res = await MyHttpClient.SendAsync(msg))
|
|
{
|
|
res.EnsureSuccessStatusCode();
|
|
using(var dest = File.Create(path))
|
|
await res.Content.CopyToAsync(dest);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
using var resp = await MyHttpClient.GetAsync($"https://www.theaudiodb.com/api/v1/json/123/artist-mb.php?i={HttpUtility.UrlEncode(id.ToString())}");
|
|
resp.EnsureSuccessStatusCode();
|
|
var respJson = await resp.Content.ReadFromJsonAsync<AudioDBArtistJsonResponse>();
|
|
|
|
if(respJson is not null && respJson.Artists is not null && respJson.Artists.Count > 0)
|
|
{
|
|
string url = respJson.Artists[0].Thumbnail;
|
|
if(string.IsNullOrWhiteSpace(url))
|
|
{
|
|
|
|
File.Copy("wwwroot/tytd-artist.jpg",path,true);
|
|
}
|
|
else {
|
|
|
|
using(var res = await MyHttpClient.GetAsync(url))
|
|
{
|
|
res.EnsureSuccessStatusCode();
|
|
using(var dest = File.Create(path))
|
|
await res.Content.CopyToAsync(dest);
|
|
}
|
|
}
|
|
|
|
}
|
|
else {
|
|
File.Copy("wwwroot/tytd-artist.jpg",path,true);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
private static async Task ArtistThumbnail(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("id",out var id))
|
|
{
|
|
string path = $"data/Thumbnails/Artists/{id}.jpg";
|
|
await EnsureArtistThumbnail(id);
|
|
if(File.Exists(path))
|
|
{
|
|
await ctx.SendFileAsync(path);
|
|
}
|
|
else
|
|
{
|
|
await ctx.SendFileAsync("wwwroot/tytd-artist.jpg");
|
|
}
|
|
}
|
|
}
|
|
public static async Task EnsureAlbumThumbnail(Guid id)
|
|
{
|
|
string path = $"data/Thumbnails/Albums/{id.ToString()}.jpg";
|
|
if(!File.Exists(path))
|
|
{
|
|
var cfg = Config ?? new AuthConfig();
|
|
HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Get,cfg.ThumbnailsThroughTYTD ? $"{cfg.TYTDUrl.TrimEnd('/')}/plugin/tytdcompanion/artist-thumbnail?id={HttpUtility.UrlEncode(id.ToString())}" : $"https://coverartarchive.org/release/{HttpUtility.UrlEncode(id.ToString())}/front");
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session) && cfg.ThumbnailsThroughTYTD)
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
using(var res = await MyHttpClient.SendAsync(msg))
|
|
{
|
|
if(res.IsSuccessStatusCode)
|
|
{
|
|
using(var dest = File.Create(path))
|
|
await res.Content.CopyToAsync(dest);
|
|
}
|
|
else {
|
|
File.Copy("wwwroot/tytd-artist.jpg",path,true);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
private static async Task AlbumThumbnail(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("id", out var id))
|
|
{
|
|
|
|
string path = $"data/Thumbnails/Albums/{id.ToString()}.jpg";
|
|
if(!File.Exists(path))
|
|
{
|
|
var cfg = Config ?? new AuthConfig();
|
|
HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Get,cfg.ThumbnailsThroughTYTD ? $"{cfg.TYTDUrl.TrimEnd('/')}/plugin/tytdcompanion/artist-thumbnail?id={HttpUtility.UrlEncode(id.ToString())}" : $"https://coverartarchive.org/release/{HttpUtility.UrlEncode(id.ToString())}/front");
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session) && cfg.ThumbnailsThroughTYTD)
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
using(var res = await MyHttpClient.SendAsync(msg))
|
|
{
|
|
if(res.IsSuccessStatusCode)
|
|
{
|
|
using(var dest = File.Create(path))
|
|
await res.Content.CopyToAsync(dest);
|
|
}
|
|
else {
|
|
File.Copy("wwwroot/tytd-artist.jpg",path,true);
|
|
}
|
|
}
|
|
|
|
}
|
|
if(File.Exists(path))
|
|
{
|
|
await ctx.SendFileAsync(path);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
private static async Task VideoThumbnail(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirst("v", out var v))
|
|
{
|
|
// TYTD/api/v1/video-thumbnail?v=il9nqWw9W3Y
|
|
VideoId? id = VideoId.TryParse(v);
|
|
if(id.HasValue)
|
|
{
|
|
string path = $"data/Thumbnails/Video/{id.Value}.jpg";
|
|
if(!File.Exists(path))
|
|
{
|
|
var cfg = Config ?? new AuthConfig();
|
|
HttpRequestMessage msg = new HttpRequestMessage(HttpMethod.Get,cfg.ThumbnailsThroughTYTD ? $"{cfg.TYTDUrl.TrimEnd('/')}/api/v1/video-thumbnail?v={id.Value.Value}&res=default" : $"https://s.ytimg.com/vi/{id.Value.Value}/default.jpg");
|
|
if(!string.IsNullOrWhiteSpace(cfg.Session) && cfg.ThumbnailsThroughTYTD)
|
|
{
|
|
msg.Headers.Authorization =new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer",cfg.Session);
|
|
}
|
|
using(var res = await MyHttpClient.SendAsync(msg))
|
|
{
|
|
res.EnsureSuccessStatusCode();
|
|
using(var dest = File.Create(path))
|
|
await res.Content.CopyToAsync(dest);
|
|
}
|
|
|
|
}
|
|
if(File.Exists(path))
|
|
{
|
|
await ctx.SendFileAsync(path);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
public static async Task SearchMore(ServerContext ctx)
|
|
{
|
|
await ctx.SendTextAsync(await Components.SearchMoreAsync(ctx));
|
|
}
|
|
public static async Task Search(ServerContext ctx)
|
|
{
|
|
await ctx.SendTextAsync(await Pages.SearchAsync(ctx));
|
|
}
|
|
public static async Task SearchDialog(ServerContext ctx)
|
|
{
|
|
await ctx.SendTextAsync(await Pages.SearchDialogAsync(ctx));
|
|
}
|
|
public static async Task Music(ServerContext ctx)
|
|
{
|
|
await ctx.SendTextAsync(Components.Shell("Music",await File.ReadAllTextAsync("wwwroot/music.html"),DefaultLinks()));
|
|
}
|
|
|
|
public static async Task MyArtist(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("id",out var id))
|
|
{
|
|
string q = "";
|
|
int page = 1;
|
|
if(!ctx.QueryParams.TryGetFirstInt32("page",out page))
|
|
page=1;
|
|
if(!ctx.QueryParams.TryGetFirst("q",out q))
|
|
q="";
|
|
|
|
List<MyAlbumLink> links=new List<MyAlbumLink>();
|
|
|
|
using(var db=new Database())
|
|
links.AddRange((await db.GetAlbumsFromArtistAsync(id.ToString(),q,(page-1)*20)).Select(e=>new MyAlbumLink(e.AlbumName,e.AlbumId,$"/api/v1/album-thumbnail?id={HttpUtility.UrlEncode(e.AlbumId)}")));
|
|
|
|
|
|
await ctx.SendTextAsync(Pages.MyArtistAlbumListing(id,q,links,page));
|
|
}
|
|
}
|
|
|
|
public static async Task Artist(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("id",out var id))
|
|
{
|
|
if(!ctx.QueryParams.TryGetFirstInt32("page",out var page))
|
|
page=1;
|
|
|
|
List<AlbumLink> links = new List<AlbumLink>();
|
|
var albumQuery = await MusicBrainzRequestAsync<AlbumQuery>($"/ws/2/release?artist={HttpUtility.UrlEncode(id.ToString())}&fmt=json&offset={(page-1)*25}&limit=25&type=album");
|
|
if(albumQuery is not null)
|
|
{
|
|
foreach(var item in albumQuery.Albums)
|
|
{
|
|
links.Add(new AlbumLink(item.Name,item.Id.ToString(),$"/api/v1/album-thumbnail?id={HttpUtility.UrlEncode(item.Id.ToString())}"));
|
|
}
|
|
}
|
|
|
|
await ctx.SendTextAsync(Pages.ArtistAlbumListing(id, links, page));
|
|
}
|
|
/*
|
|
if(ctx.QueryParams.TryGetFirst("id",out var id))
|
|
{
|
|
await ctx.SendTextAsync(Pages.ArtistInfo(await YouTubeMusicClient.GetArtistInfoAsync(id)));
|
|
}
|
|
*/
|
|
}
|
|
public static async Task FixIncorrectPost(ServerContext ctx)
|
|
{
|
|
ctx.ParseBody();
|
|
VideoId? myId;
|
|
if(ctx.QueryParams.TryGetFirstGuid("songId",out var songId) && ctx.QueryParams.TryGetFirstGuid("albumId",out var albumId) && ctx.QueryParams.TryGetFirst("url",out var url) && (myId=VideoId.TryParse(url)).HasValue)
|
|
{
|
|
|
|
var info = await YouTubeClient.Videos.GetAsync(myId.Value);
|
|
using(var db = new Database())
|
|
{
|
|
VideoId? vid = await db.GetVideoIdAsync(songId.ToString());
|
|
if(vid.HasValue)
|
|
{
|
|
string path = $"data/MusicFromTYTD/{vid.Value.Value}.bin";
|
|
if(File.Exists(path)) File.Delete(path);
|
|
}
|
|
await db.UpdateVideoIdAsync(songId.ToString(),myId.Value.Value,info.Title);
|
|
await foreach(var rel in db.GetMediaEntriesAsync(songId.ToString()))
|
|
{
|
|
string path = rel.ToString();
|
|
if(File.Exists(path)) File.Delete(path);
|
|
}
|
|
|
|
}
|
|
|
|
AddVideo(myId.Value.Value, TYTDResolution.AudioOnly);
|
|
//await ctx.SendTextAsync($"<p>{HttpUtility.HtmlEncode($"SongId: {songId}, AlbumId: {albumId}, Url: {url}")}</p>");
|
|
|
|
|
|
await RedirectAsync(ctx,$"/music/mysong?songId={HttpUtility.UrlEncode(songId.ToString())}&albumId={HttpUtility.UrlEncode(albumId.ToString())}");
|
|
}
|
|
|
|
}
|
|
public static async Task FixIncorrectGet(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("songId",out var songId) && ctx.QueryParams.TryGetFirstGuid("albumId",out var albumId))
|
|
{
|
|
StringBuilder builder = new StringBuilder();
|
|
|
|
using(var db = new Database())
|
|
{
|
|
var song = await db.GetSongAsync(songId.ToString());
|
|
if(song is not null)
|
|
{
|
|
int i = 0;
|
|
foreach(var artist in await db.GetContributingArtistsAsync(songId.ToString()))
|
|
{
|
|
if(i == 0)
|
|
builder.Append($"{artist.ArtistName} - {song.SongName}");
|
|
else if(i == 1)
|
|
builder.Append($" feat {artist.ArtistName}");
|
|
else
|
|
builder.Append($", {artist.ArtistName}");
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
await ctx.SendTextAsync(Pages.IsntCorrect(songId.ToString(),albumId.ToString(),builder.ToString()));
|
|
}
|
|
}
|
|
public static async Task MySong(ServerContext ctx)
|
|
{
|
|
var cfg = Config ?? new AuthConfig();
|
|
if(ctx.QueryParams.TryGetFirstGuid("songId",out var songId))
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("albumId",out var albumId))
|
|
{
|
|
string html;
|
|
using(var db = new Database())
|
|
{
|
|
var song = await db.GetSongAsync(songId.ToString());
|
|
var album = await db.GetAlbumAsync(albumId.ToString());
|
|
var trk = await db.GetTrackAsync(songId.ToString(), albumId.ToString());
|
|
var video = await db.GetSongVideoFromSongIdAsync(songId.ToString());
|
|
var file = await db.GetMediaEntryAsync(albumId.ToString(),songId.ToString());
|
|
if(song is not null && album is not null && trk is not null && file is not null)
|
|
{
|
|
video ??= new SongVideo() {
|
|
SongId = songId.ToString(),
|
|
VideoTitle = "No Video",
|
|
|
|
};
|
|
|
|
var artists = await db.GetContributingArtistsAsync(songId.ToString());
|
|
html =Pages.MySong(song,album,video,cfg.TYTDUrl,File.Exists(file.ToString()),trk.Track,TimeSpan.FromSeconds(trk.Length/1000),artists.ToList());
|
|
}
|
|
else
|
|
html = Components.Shell("Song not found","<h1>Song not found</h1>", DefaultLinks());
|
|
}
|
|
|
|
await ctx.SendTextAsync(html);
|
|
}
|
|
else
|
|
{
|
|
List<MediaEntry> entries=new List<MediaEntry>();
|
|
using(var db = new Database())
|
|
{
|
|
await foreach(var item in db.GetMediaEntriesAsync(songId.ToString()))
|
|
{
|
|
entries.Add(item);
|
|
}
|
|
}
|
|
|
|
if(entries.Count == 0)
|
|
{
|
|
ctx.SendText(Components.Shell("Song not found","<h1>Song not found</h1>", DefaultLinks()));
|
|
}
|
|
else if(entries.Count == 1)
|
|
{
|
|
await RedirectAsync(ctx,$"/music/mysong?songId={HttpUtility.UrlEncode(songId.ToString())}&albumId={HttpUtility.UrlEncode(entries[0].AlbumId)}");
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
public static async Task MySongs(ServerContext ctx)
|
|
{
|
|
string q = "";
|
|
int page = 1;
|
|
if(!ctx.QueryParams.TryGetFirstInt32("page",out page))
|
|
page=1;
|
|
if(!ctx.QueryParams.TryGetFirst("q",out q))
|
|
q="";
|
|
|
|
List<MySongLink> links=new List<MySongLink>();
|
|
|
|
using(var db=new Database())
|
|
{
|
|
foreach(var item in await db.GetSongsAsync(q,(page-1)*20))
|
|
{
|
|
int i=0;
|
|
StringBuilder builder = new StringBuilder();
|
|
foreach(var artist in await db.GetContributingArtistsAsync(item.SongId))
|
|
{
|
|
if(i == 0)
|
|
builder.Append($"{artist.ArtistName} - {item.SongName}");
|
|
else if(i == 1)
|
|
builder.Append($" feat {artist.ArtistName}");
|
|
else
|
|
builder.Append($", {artist.ArtistName}");
|
|
i++;
|
|
}
|
|
|
|
string? html = null;
|
|
|
|
await foreach(var album in db.GetMediaEntriesAsync(item.SongId))
|
|
{
|
|
if(html is null) html = File.Exists(album.ToString()) ? $"<a class=\"transparent\" href=\"/api/v1/song?albumId={HttpUtility.UrlEncode(album.AlbumId)}&songId={HttpUtility.UrlEncode(item.SongId)}\"><i>download</i></a>" : ((await db.GetSongVideoFromSongIdAsync(item.SongId)) is not null ? "<i>downloading</i>" : "<i>file_download_off</i>");
|
|
else {
|
|
html="<i>list</i>";
|
|
break;
|
|
}
|
|
}
|
|
|
|
links.Add(new MySongLink(builder.ToString(),item.SongId,html ?? ""));
|
|
}
|
|
//links.AddRange(().Select(e=>new MyArtistLink(e.ArtistName,e.ArtistId,$"/api/v1/artist-thumbnail?id={HttpUtility.UrlEncode(e.ArtistId)}")));
|
|
}
|
|
|
|
await ctx.SendTextAsync(Pages.MySongListing(q,links,page));
|
|
}
|
|
public static async Task MyArtists(ServerContext ctx)
|
|
{
|
|
string q = "";
|
|
int page = 1;
|
|
if(!ctx.QueryParams.TryGetFirstInt32("page",out page))
|
|
page=1;
|
|
if(!ctx.QueryParams.TryGetFirst("q",out q))
|
|
q="";
|
|
|
|
List<MyArtistLink> links=new List<MyArtistLink>();
|
|
|
|
using(var db=new Database())
|
|
links.AddRange((await db.GetArtistsAsync(q,(page-1)*20)).Select(e=>new MyArtistLink(e.ArtistName,e.ArtistId,$"/api/v1/artist-thumbnail?id={HttpUtility.UrlEncode(e.ArtistId)}")));
|
|
|
|
|
|
await ctx.SendTextAsync(Pages.MyArtistListing(q,links,page));
|
|
}
|
|
public static async Task MyAlbums(ServerContext ctx)
|
|
{
|
|
string q = "";
|
|
int page = 1;
|
|
if(!ctx.QueryParams.TryGetFirstInt32("page",out page))
|
|
page=1;
|
|
if(!ctx.QueryParams.TryGetFirst("q",out q))
|
|
q="";
|
|
|
|
List<MyAlbumLink> links=new List<MyAlbumLink>();
|
|
|
|
using(var db=new Database())
|
|
links.AddRange((await db.GetAlbumsAsync(q,(page-1)*20)).Select(e=>new MyAlbumLink(e.AlbumName,e.AlbumId,$"/api/v1/album-thumbnail?id={HttpUtility.UrlEncode(e.AlbumId)}")));
|
|
|
|
|
|
await ctx.SendTextAsync(Pages.MyAlbumListing(q,links,page));
|
|
}
|
|
public static async Task Artists(ServerContext ctx)
|
|
{
|
|
|
|
List<ArtistLink> links = new List<ArtistLink>();
|
|
string q = "";
|
|
int page = 1;
|
|
if(ctx.QueryParams.TryGetFirst("q",out q))
|
|
{
|
|
|
|
if(!ctx.QueryParams.TryGetFirstInt32("page",out page))
|
|
page=1;
|
|
|
|
var artistQuery = await MusicBrainzRequestAsync<ArtistQuery>($"/ws/2/artist?query={HttpUtility.UrlEncode(q)}&fmt=json&offset={(page-1)*25}&limit=25");
|
|
if(artistQuery is not null)
|
|
{
|
|
foreach(var item in artistQuery.Artists)
|
|
{
|
|
links.Add(new ArtistLink(item.Name,item.Id.ToString(),$"/api/v1/artist-thumbnail?id={HttpUtility.UrlEncode(item.Id.ToString())}"));
|
|
}
|
|
}
|
|
/*await foreach(var item in (q,10,0,true))
|
|
{
|
|
Console.WriteLine(item.Item.Name);
|
|
}*/
|
|
}
|
|
|
|
await ctx.SendTextAsync(Pages.ArtistListing(q,links,page));
|
|
|
|
}
|
|
public static async Task MyAlbum(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("id",out var id))
|
|
{
|
|
string albumName = "";
|
|
bool hasAny=false;
|
|
StringBuilder artistsString = new StringBuilder();
|
|
|
|
List<MyAlbumSongLink> links = new List<MyAlbumSongLink>();
|
|
using(var db = new Database())
|
|
{
|
|
var album = await db.GetAlbumAsync(id.ToString());
|
|
if(album is not null)
|
|
{
|
|
albumName = album.AlbumName;
|
|
}
|
|
var artists = await db.GetAlbumArtistsAsync(id.ToString());
|
|
|
|
bool firstArtist = true;
|
|
|
|
foreach(var item in artists)
|
|
{
|
|
if(!firstArtist)
|
|
artistsString.Append(", ");
|
|
|
|
string artistEncoded = HttpUtility.UrlEncode(item.ArtistId);
|
|
|
|
artistsString.Append("<a hx-target=\"body\" hx-push-url=\"true\" hx-get=\"/music/myartist?id=");
|
|
artistsString.Append(artistEncoded);
|
|
artistsString.Append("\" href=\"/music/myartist?id=");
|
|
artistsString.Append(artistEncoded);
|
|
artistsString.Append("\">");
|
|
artistsString.Append(HttpUtility.HtmlEncode(item.ArtistName));
|
|
artistsString.Append("</a>");
|
|
|
|
firstArtist=false;
|
|
}
|
|
|
|
var tracks = await db.GetTracksAsync(id.ToString());
|
|
|
|
//hasAnySongs
|
|
foreach(var item in tracks)
|
|
{
|
|
var me=await db.GetMediaEntryAsync(id.ToString(),item.SongId);
|
|
if(me is not null)
|
|
{
|
|
bool hasSong = File.Exists(me.ToString());
|
|
links.Add(new MyAlbumSongLink(me.TrackIndex,item.SongName,id.ToString(),item.SongId,TimeSpan.FromSeconds(item.Length/1000),
|
|
hasSong ? $"<a class=\"transparent\" href=\"/api/v1/song?albumId={HttpUtility.UrlEncode(id.ToString())}&songId={HttpUtility.UrlEncode(item.SongId)}\"><i>download</i></a>" : ((await db.GetSongVideoFromSongIdAsync(item.SongId)) is not null ? "<i>downloading</i>" : "<i>file_download_off</i>")
|
|
));
|
|
if(hasSong) hasAny=true;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*if(albumQuery is not null)
|
|
{
|
|
albumName = albumQuery.Title;
|
|
var first = albumQuery.Media.FirstOrDefault();
|
|
if(first is not null)
|
|
foreach(var item in first.Tracks)
|
|
{
|
|
links.Add(new AlbumSongLink(item.Track,item.Recording.Name,item.Recording.Id.ToString(),TimeSpan.FromSeconds(item.Length/1000)));
|
|
}
|
|
}*/
|
|
|
|
await ctx.SendTextAsync(Pages.MyAlbumInfo(albumName, id.ToString(), links,hasAny, artistsString.ToString()));
|
|
}
|
|
|
|
}
|
|
public static async Task Album(ServerContext ctx)
|
|
{
|
|
if(ctx.QueryParams.TryGetFirstGuid("id",out var id))
|
|
{
|
|
|
|
List<AlbumSongLink> links = new List<AlbumSongLink>();
|
|
var albumQuery = await MusicBrainzRequestAsync<AlbumSongQuery>($"/ws/2/release/{HttpUtility.UrlEncode(id.ToString())}/?inc=recordings&fmt=json");
|
|
string albumName = "";
|
|
|
|
if(albumQuery is not null)
|
|
{
|
|
albumName = albumQuery.Title;
|
|
var first = albumQuery.Media.FirstOrDefault();
|
|
if(first is not null)
|
|
foreach(var item in first.Tracks)
|
|
{
|
|
links.Add(new AlbumSongLink(item.Track,item.Recording.Name,id.ToString(),item.Recording.Id.ToString(),TimeSpan.FromSeconds(item.Length/1000)));
|
|
}
|
|
}
|
|
|
|
await ctx.SendTextAsync(Pages.AlbumInfo(albumName, id.ToString(), links));
|
|
}
|
|
|
|
}
|
|
public static async Task Albums(ServerContext ctx)
|
|
{
|
|
List<AlbumLink> links = new List<AlbumLink>();
|
|
string q = "";
|
|
int page = 1;
|
|
if(ctx.QueryParams.TryGetFirst("q",out q))
|
|
{
|
|
|
|
if(!ctx.QueryParams.TryGetFirstInt32("page",out page))
|
|
page=1;
|
|
|
|
var albumQuery = await MusicBrainzRequestAsync<AlbumQuery>($"/ws/2/release?query={HttpUtility.UrlEncode(q)}&fmt=json&offset={(page-1)*25}&limit=25");
|
|
if(albumQuery is not null)
|
|
{
|
|
foreach(var item in albumQuery.Albums)
|
|
{
|
|
links.Add(new AlbumLink(item.Name,item.Id.ToString(),$"/api/v1/album-thumbnail?id={HttpUtility.UrlEncode(item.Id.ToString())}"));
|
|
}
|
|
}
|
|
}
|
|
|
|
await ctx.SendTextAsync(Pages.AlbumListing(q,links,page));
|
|
/*
|
|
List<AlbumLink> links = new List<AlbumLink>();
|
|
string q = "";
|
|
if(ctx.QueryParams.TryGetFirst("q",out q))
|
|
{
|
|
await foreach(var item in YouTubeMusicClient.SearchAsync(q,YouTubeMusicAPI.Models.Search.SearchCategory.Albums))
|
|
{
|
|
string url="";
|
|
foreach(var thumb in item.Thumbnails)
|
|
{
|
|
if(thumb.Width == 226) url = thumb.Url;
|
|
}
|
|
links.Add(new AlbumLink(item.Name,item.Id,url));
|
|
}
|
|
}
|
|
|
|
await ctx.SendTextAsync(Pages.AlbumListing(q,links));
|
|
*/
|
|
}
|
|
|
|
static ConcurrentBag<IEventable> eventables=new ConcurrentBag<IEventable>();
|
|
|
|
public static void RegisterEventable(IEventable evt)
|
|
{
|
|
eventables.Add(evt);
|
|
}
|
|
|
|
public class OneUseTokenData
|
|
{
|
|
/*
|
|
username = user.username,
|
|
flags = user.flags,
|
|
token = token,
|
|
sso_app_key = sso.sso_app_key
|
|
*/
|
|
[JsonProperty("username")]
|
|
public string Username {get;set;}="";
|
|
|
|
[JsonProperty("flags")]
|
|
public long Flags {get;set;}
|
|
|
|
[JsonProperty("token")]
|
|
public string Token {get;set;}="";
|
|
|
|
[JsonProperty("sso_app_key")]
|
|
public string SSOAppKey {get;set;}="";
|
|
}
|
|
}
|
|
|
|
|
|
} |