glax/Tranga
1
0
Fork 0
mirror of https://github.com/C9Glax/tranga.git synced 2025-10-11 13:19:48 +02:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

LibraryConnector-Updates work

Browse Source 
Fixes #418
This commit is contained in:
glax
2025-09-18 00:42:46 +02:00
parent 55fb37d62b
commit 5af1605c5b
16 changed files with 125 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
API/Schema/LibraryContext/LibraryConnectors/Kavita.cs
View File

@@ -1,15 +1,12 @@
using System.Text.Json;
using System.Text.Json.Nodes;
using Newtonsoft.Json;
using JsonSerializer = System.Text.Json.JsonSerializer;
namespace API.Schema.LibraryContext.LibraryConnectors;
public class Kavita : LibraryConnector
public class Kavita(string baseUrl, string auth) : LibraryConnector(LibraryType.Kavita, baseUrl, auth)
{
public Kavita(string baseUrl, string auth) : base(LibraryType.Kavita, baseUrl, auth)
{
}
public Kavita(string baseUrl, string username, string password) :
this(baseUrl, GetToken(baseUrl, username, password))
{
@@ -51,16 +48,23 @@ public class Kavita : LibraryConnector
return "";
}
protected override void UpdateLibraryInternal()
public override async Task UpdateLibrary(CancellationToken ct)
{
foreach (KavitaLibrary lib in GetLibraries())
NetClient.MakePost($"{BaseUrl}/api/ToFileLibrary/scan?libraryId={lib.id}", "Bearer", Auth);
try
{
foreach (KavitaLibrary lib in await GetLibraries(ct))
await NetClient.MakeRequest($"{BaseUrl}/api/ToFileLibrary/scan?libraryId={lib.Id}", "Bearer", Auth, HttpMethod.Post, ct);
}
catch (Exception e)
{
Log.Error(e);
}
}
internal override bool Test()
internal override async Task<bool> Test(CancellationToken ct)
{
foreach (KavitaLibrary lib in GetLibraries())
if (NetClient.MakePost($"{BaseUrl}/api/ToFileLibrary/scan?libraryId={lib.id}", "Bearer", Auth))
foreach (KavitaLibrary lib in await GetLibraries(ct))
if (await NetClient.MakeRequest($"{BaseUrl}/api/ToFileLibrary/scan?libraryId={lib.Id}", "Bearer", Auth, HttpMethod.Post, ct) is { CanRead: true })
return true;
return false;
}
@@ -69,46 +73,28 @@ public class Kavita : LibraryConnector
/// Fetches all libraries available to the user
/// </summary>
/// <returns>Array of KavitaLibrary</returns>
private IEnumerable<KavitaLibrary> GetLibraries()
private async Task<IEnumerable<KavitaLibrary>> GetLibraries(CancellationToken ct)
{
Stream data = NetClient.MakeRequest($"{BaseUrl}/api/ToFileLibrary/libraries", "Bearer", Auth);
if (data == Stream.Null)
if(await NetClient.MakeRequest($"{BaseUrl}/api/ToFileLibrary/libraries", "Bearer", Auth, HttpMethod.Get, ct) is not { CanRead: true } data)
{
Log.Info("No libraries found");
return [];
}
JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
if (result is null)
if(await JsonSerializer.DeserializeAsync<KavitaLibrary[]>(data, JsonSerializerOptions.Web, ct) is not { } ret)
{
Log.Info("No libraries found");
Log.Debug("Parsing libraries failed.");
return [];
}
List<KavitaLibrary> ret = new();
foreach (JsonNode? jsonNode in result)
{
JsonObject? jObject = (JsonObject?)jsonNode;
if(jObject is null)
continue;
int libraryId = jObject["id"]!.GetValue<int>();
string libraryName = jObject["name"]!.GetValue<string>();
ret.Add(new KavitaLibrary(libraryId, libraryName));
}
return ret;
}
private struct KavitaLibrary
{
public int id { get; }
[JsonProperty("id")]
public required int Id { get; init; }
// ReSharper disable once UnusedAutoPropertyAccessor.Local
public string name { get; }
public KavitaLibrary(int id, string name)
{
this.id = id;
this.name = name;
}
[JsonProperty("name")]
public required string Name { get; init; }
}
}

69
API/Schema/LibraryContext/LibraryConnectors/Komga.cs
View File

@@ -1,29 +1,33 @@
using System.Text.Json;
using System.Text.Json.Nodes;
using Newtonsoft.Json;
using JsonSerializer = System.Text.Json.JsonSerializer;
namespace API.Schema.LibraryContext.LibraryConnectors;
public class Komga : LibraryConnector
public class Komga(string baseUrl, string auth) : LibraryConnector(LibraryType.Komga, baseUrl, auth)
{
public Komga(string baseUrl, string auth) : base(LibraryType.Komga, baseUrl, auth)
{
}
public Komga(string baseUrl, string username, string password)
: this(baseUrl, Convert.ToBase64String(System.Text.Encoding.ASCII.GetBytes($"{username}:{password}")))
{
}
protected override void UpdateLibraryInternal()
public override async Task UpdateLibrary(CancellationToken ct)
{
foreach (KomgaLibrary lib in GetLibraries())
NetClient.MakePost($"{BaseUrl}/api/v1/libraries/{lib.id}/scan", "Basic", Auth);
try
{
foreach (KomgaLibrary lib in await GetLibraries(ct))
await NetClient.MakeRequest($"{BaseUrl}/api/v1/libraries/{lib.Id}/scan", "Basic", Auth, HttpMethod.Post, ct);
}
catch (Exception e)
{
Log.Error(e);
}
}
internal override bool Test()
internal override async Task<bool> Test(CancellationToken ct)
{
foreach (KomgaLibrary lib in GetLibraries())
if (NetClient.MakePost($"{BaseUrl}/api/v1/libraries/{lib.id}/scan", "Basic", Auth))
foreach (KomgaLibrary lib in await GetLibraries(ct))
if (await NetClient.MakeRequest($"{BaseUrl}/api/v1/libraries/{lib.Id}/scan", "Basic", Auth, HttpMethod.Post, ct) is { CanRead: true})
return true;
return false;
}
@@ -32,44 +36,31 @@ public class Komga : LibraryConnector
/// Fetches all libraries available to the user
/// </summary>
/// <returns>Array of KomgaLibraries</returns>
private IEnumerable<KomgaLibrary> GetLibraries()
private async Task<IEnumerable<KomgaLibrary>> GetLibraries(CancellationToken ct)
{
Stream data = NetClient.MakeRequest($"{BaseUrl}/api/v1/libraries", "Basic", Auth);
if (data == Stream.Null)
if (await NetClient.MakeRequest($"{BaseUrl}/api/v1/libraries", "Basic", Auth, HttpMethod.Get, ct) is not { CanRead: true } data)
{
Log.Info("No libraries found");
return [];
}
JsonArray? result = JsonSerializer.Deserialize<JsonArray>(data);
if (result is null)
{
Log.Info("No libraries found");
Log.Debug("No libraries found");
return [];
}
HashSet<KomgaLibrary> ret = new();
foreach (JsonNode? jsonNode in result)
if (await JsonSerializer.DeserializeAsync<KomgaLibrary[]>(data, JsonSerializerOptions.Web, ct) is not
{ } ret)
{
var jObject = (JsonObject?)jsonNode;
string libraryId = jObject!["id"]!.GetValue<string>();
string libraryName = jObject["name"]!.GetValue<string>();
ret.Add(new KomgaLibrary(libraryId, libraryName));
Log.Debug("Parsing libraries failed.");
return [];
}
return ret;
return ret ;
}
private struct KomgaLibrary
private readonly record struct KomgaLibrary
{
public string id { get; }
// ReSharper disable once UnusedAutoPropertyAccessor.Local
public string name { get; }
[JsonProperty("id")]
public required string Id { get; init; }
public KomgaLibrary(string id, string name)
{
this.id = id;
this.name = name;
}
// ReSharper disable once UnusedAutoPropertyAccessor.Local
[JsonProperty("name")]
public required string Name { get; init; }
}
}

7
API/Schema/LibraryContext/LibraryConnectors/LibraryConnector.cs
View File

@@ -2,7 +2,6 @@
using System.ComponentModel.DataAnnotations.Schema;
using log4net;
using Microsoft.EntityFrameworkCore;
using Newtonsoft.Json;
namespace API.Schema.LibraryContext.LibraryConnectors;
@@ -18,7 +17,7 @@ public abstract class LibraryConnector : Identifiable
: base()
{
this.LibraryType = libraryType;
this.BaseUrl = baseUrl;
this.BaseUrl = baseUrl.TrimEnd('/', ' ');
this.Auth = auth;
this.Log = LogManager.GetLogger(GetType());
}
@@ -37,8 +36,8 @@ public abstract class LibraryConnector : Identifiable
public override string ToString() => $"{base.ToString()} {this.LibraryType} {this.BaseUrl}";
protected abstract void UpdateLibraryInternal();
internal abstract bool Test();
public abstract Task UpdateLibrary(CancellationToken ct);
internal abstract Task<bool> Test(CancellationToken ct);
}
public enum LibraryType : byte

67
API/Schema/LibraryContext/LibraryConnectors/NetClient.cs
View File

@@ -1,35 +1,41 @@
using System.Net;
using System.Net.Http.Headers;
using log4net;
using HttpMethod = System.Net.Http.HttpMethod;
namespace API.Schema.LibraryContext.LibraryConnectors;
public class NetClient
{
private static ILog Log = LogManager.GetLogger(typeof(NetClient));
private static readonly ILog Log = LogManager.GetLogger(typeof(NetClient));
private static readonly HttpClient Client = new();
public static Stream MakeRequest(string url, string authScheme, string auth)
public static async Task<Stream> MakeRequest(string url, string authScheme, string auth, HttpMethod? method = null, CancellationToken? cancellationToken = null)
{
Log.Debug($"Requesting {url}");
HttpClient client = new();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(authScheme, auth);
HttpRequestMessage requestMessage = new()
{
Method = HttpMethod.Get,
RequestUri = new Uri(url)
};
method ??= HttpMethod.Get;
CancellationToken ct = cancellationToken ?? CancellationToken.None;
Client.DefaultRequestHeaders.Authorization = new (authScheme, auth);
try
{
HttpResponseMessage response = client.Send(requestMessage);
HttpRequestMessage requestMessage = new()
{
Method = method,
RequestUri = new (url),
Headers =
{
{ "Accept", "application/json" },
{ "Authorization", new AuthenticationHeaderValue(authScheme, auth).ToString() }
}
};
HttpResponseMessage response = await Client.SendAsync(requestMessage, ct);
if (response.StatusCode is HttpStatusCode.Unauthorized &&
response.RequestMessage!.RequestUri!.AbsoluteUri != url)
return MakeRequest(response.RequestMessage!.RequestUri!.AbsoluteUri, authScheme, auth);
else if (response.IsSuccessStatusCode)
return response.Content.ReadAsStream();
else
return Stream.Null;
if (response.StatusCode is HttpStatusCode.Unauthorized && response.RequestMessage?.RequestUri?.AbsoluteUri is { } absoluteUri && absoluteUri != url)
return await MakeRequest(absoluteUri, authScheme, auth, method, ct);
if (response.IsSuccessStatusCode)
return await response.Content.ReadAsStreamAsync(ct);
return Stream.Null;
}
catch (Exception e)
{
@@ -45,29 +51,4 @@ public class NetClient
return Stream.Null;
}
}
public static bool MakePost(string url, string authScheme, string auth)
{
HttpClient client = new()
{
DefaultRequestHeaders =
{
{ "Accept", "application/json" },
{ "Authorization", new AuthenticationHeaderValue(authScheme, auth).ToString() }
}
};
HttpRequestMessage requestMessage = new ()
{
Method = HttpMethod.Post,
RequestUri = new Uri(url)
};
HttpResponseMessage response = client.Send(requestMessage);
if(response.StatusCode is HttpStatusCode.Unauthorized && response.RequestMessage!.RequestUri!.AbsoluteUri != url)
return MakePost(response.RequestMessage!.RequestUri!.AbsoluteUri, authScheme, auth);
else if (response.IsSuccessStatusCode)
return true;
else
return false;
}
}