eumario/freetubesync
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Started the Split

Browse source 
Split Json data models coming from REST Api, from the Database models
storing them in a SQLite database.
Work to re-engineer endpoints to use Database objects, and copy/update
data from the json objects.
More work is needed.
This commit is contained in:
Mario Steele 2025-07-22 17:03:33 -05:00
parent 157d46ee2e
commit 4985dc4179
36 changed files with 684 additions and 323 deletions
Download patch file Download diff file Expand all files Collapse all files

20
FreeTubeSync/EndPoints/HistoryEndpoint.cs
View file

@ -1,4 +1,6 @@
using FreeTubeSync.Model;
using FreeTubeSync.Database;
using FreeTubeSync.Model.Database;
using FreeTubeSync.Model.Json;
namespace FreeTubeSync.EndPoints;
@ -11,17 +13,23 @@ public static class HistoryEndpoint
group.MapGet("/", async (IRepository<History> repository, CancellationToken ct) =>
{
var results = await repository.GetAllAsync(ct);
return Results.Ok(results);
var jsonResults = new List<HistoryJson>();
results.MapTo(jsonResults);
return Results.Ok(jsonResults);
});
group.MapPost("/", async (IRepository<History> repository, CancellationToken ct, History history) =>
group.MapPost("/", async (IRepository<History> repository, CancellationToken ct, HistoryJson historyJson) =>
{
var results = await repository.GetByIdAsync(history._id, ct);
var results = await repository.GetByIdAsync(historyJson._id, ct);
if (results == null)
await repository.AddAsync(history, ct);
{
results = new History();
results.MapFrom(historyJson);
await repository.AddAsync(results, ct);
}
else
{
results.Update(history);
results.MapFrom(historyJson);
await repository.UpdateAsync(results, ct);
}
return Results.Ok();

51
FreeTubeSync/EndPoints/PlaylistEndpoint.cs
View file

@ -1,4 +1,6 @@
using FreeTubeSync.Model;
using FreeTubeSync.Database;
using FreeTubeSync.Model.Database;
using FreeTubeSync.Model.Json;
namespace FreeTubeSync.EndPoints;
@ -10,18 +12,53 @@ public static class PlaylistEndpoint
group.MapGet("/", async (IRepository<Playlist> repository, CancellationToken ct) =>
{
var results = await repository.GetAllAsync(ct);
return Results.Ok(results);
var results = (await repository.GetAllAsync(ct)).ToList();
var jsonResults = new List<PlaylistJson>();
results.MapTo(jsonResults);
for (var i = 0; i < jsonResults.Count; i++)
results[i].videos.MapTo(jsonResults[i].videos);
return Results.Ok(jsonResults);
});
group.MapPost("/", async (IRepository<Playlist> repository, CancellationToken ct, Playlist playlist) =>
group.MapPost("/", async (IRepository<Playlist> repository, IRepository<Video> vidRepo, CancellationToken ct, PlaylistJson playlistJson) =>
{
var results = await repository.GetByIdAsync(playlist._id, ct);
var results = await repository.GetByIdAsync(playlistJson._id, ct);
if (results == null)
await repository.AddAsync(playlist, ct);
{
results = new Playlist();
results.MapFrom(playlistJson);
foreach (var video in playlistJson.videos)
{
var vid = new Video();
vid.MapFrom(video);
await vidRepo.AddAsync(vid, ct, false);
}
await repository.AddAsync(results, ct);
}
else
{
results.Update(playlist);
results.MapFrom(playlistJson);
var remove = results.videos.Where(video => playlistJson.videos.All(x => x.playlistItemId != video.playlistItemId)).ToList();
var add = playlistJson.videos.Where(video => results.videos.All(x => x.playlistItemId != video.playlistItemId)).ToList();
var vids = new List<Video>();
foreach (var video in remove)
{
await vidRepo.DeleteAsync(video, ct, false);
}
foreach (var video in add)
{
var vid = new Video();
vid.MapFrom(video);
await vidRepo.AddAsync(vid, ct, false);
vids.Add(vid);
}
results.videos.RemoveAll(x => remove.Contains(x));
results.videos.AddRange(vids);
await repository.UpdateAsync(results, ct);
}

63
FreeTubeSync/EndPoints/ProfileEndpoint.cs
View file

@ -1,4 +1,6 @@
using FreeTubeSync.Model;
using FreeTubeSync.Database;
using FreeTubeSync.Model.Database;
using FreeTubeSync.Model.Json;
namespace FreeTubeSync.EndPoints;
@ -10,18 +12,67 @@ public static class ProfileEndpoint
group.MapGet("/", async (IRepository<Profile> repository, CancellationToken ct) =>
{
var results = await repository.GetAllAsync(ct);
var results = (await repository.GetAllAsync(ct)).ToList();
var jsonResults = new List<ProfileJson>();
results.MapTo(jsonResults);
for (var i = 0; i < jsonResults.Count; i++)
results[i].subscriptions.MapTo(jsonResults[i].subscriptions);
return Results.Ok(results);
});
group.MapPost("/", async (IRepository<Profile> repository, CancellationToken ct, Profile profile) =>
group.MapPost("/", async (IRepository<Profile> repository, IRepository<Subscription> subRepo, CancellationToken ct, ProfileJson profileJson) =>
{
var res = await repository.GetByIdAsync(profile._id, ct);
var res = await repository.GetByIdAsync(profileJson._id, ct);
if (res == null)
await repository.AddAsync(profile, ct);
{
res = new Profile();
res.MapFrom(profileJson);
foreach (var subscription in profileJson.subscriptions)
{
var sub = await subRepo.GetByIdAsync(subscription.id, ct);
if (sub == null)
{
sub = new Subscription();
sub.MapFrom(subscription);
await subRepo.AddAsync(sub, ct, false);
}
res.subscriptions.Add(sub);
}
await repository.AddAsync(res, ct);
}
else
{
res.Update(profile);
res.MapFrom(profileJson);
var notFound = new List<Subscription>();
foreach (var subscription in res.subscriptions)
{
var f = profileJson.subscriptions.FirstOrDefault(s => s.id == subscription.id);
if (f == null)
notFound.Add(subscription);
else
subscription.MapFrom(f);
}
var newSubs = (from subscription in profileJson.subscriptions let f = res.subscriptions.FirstOrDefault(s => s.id == subscription.id) where f == null select subscription).ToList();
foreach (var newSub in newSubs)
{
var sres = await subRepo.GetByIdAsync(newSub.id, ct);
if (sres == null)
{
sres = new Subscription();
sres.MapFrom(newSub);
await subRepo.AddAsync(sres, ct, false);
}
res.subscriptions.Add(sres);
}
foreach (var nfSub in notFound)
{
res.subscriptions.Remove(nfSub);
}
await repository.UpdateAsync(res, ct);
}

20
FreeTubeSync/EndPoints/SearchHistoryEndpoint.cs
View file

@ -1,4 +1,6 @@
using FreeTubeSync.Model;
using FreeTubeSync.Database;
using FreeTubeSync.Model.Database;
using FreeTubeSync.Model.Json;
namespace FreeTubeSync.EndPoints;
@ -11,17 +13,23 @@ public static class SearchHistoryEndpoint
group.MapGet("/", async (IRepository<SearchHistory> repository, CancellationToken ct) =>
{
var result = await repository.GetAllAsync(ct);
return Results.Ok(result);
var jsonResults = new List<SearchHistoryJson>();
result.MapTo(jsonResults);
return Results.Ok(jsonResults);
});
group.MapPost("/", async (IRepository<SearchHistory> repository, CancellationToken ct, SearchHistory history) =>
group.MapPost("/", async (IRepository<SearchHistory> repository, CancellationToken ct, SearchHistoryJson historyJson) =>
{
var result = await repository.GetByIdAsync(history._id, ct);
var result = await repository.GetByIdAsync(historyJson._id, ct);
if (result == null)
await repository.AddAsync(history, ct);
{
result = new SearchHistory();
result.MapFrom(historyJson);
await repository.AddAsync(result, ct);
}
else
{
result.Update(history);
result.MapFrom(historyJson);
await repository.UpdateAsync(result, ct);
}

22
FreeTubeSync/EndPoints/SettingEndpoint.cs
View file

@ -1,5 +1,6 @@
using FreeTubeSync.Model;
using FreeTubeSync.SpecialResponses;
using FreeTubeSync.Database;
using FreeTubeSync.Model.Database;
using FreeTubeSync.Model.Json;
namespace FreeTubeSync.EndPoints;
@ -12,18 +13,23 @@ public static class SettingEndpoint
group.MapGet("/", async (IRepository<Setting> repository, CancellationToken ct) =>
{
var settings = await repository.GetAllAsync(ct);
var response = settings.MapToResponse();
return Results.Ok(response);
var jsonSettings = new List<SettingJson>();
settings.MapTo(jsonSettings);
return Results.Ok(jsonSettings);
});
group.MapPost("/", async (IRepository<Setting> repository, CancellationToken ct, Setting setting) =>
group.MapPost("/", async (IRepository<Setting> repository, CancellationToken ct, SettingJson settingJson) =>
{
var res = await repository.GetByIdAsync(setting._id, ct);
var res = await repository.GetByIdAsync(settingJson._id, ct);
if (res == null)
await repository.AddAsync(setting, ct);
{
res = new Setting();
res.MapFrom(settingJson);
await repository.AddAsync(res, ct);
}
else
{
res.Update(setting);
res.MapFrom(settingJson);
await repository.UpdateAsync(res, ct);
}
return Results.Ok();