Possibly fix issues

After doing testing with a test project, re-organized code to new method
of storing, as well as ensure that all Endpoint lambda's are separated
out into functions.

Large commit, will be testing.

FreeTubeSync/Database/DataContext.cs

@@ -1,4 +1,4 @@
-using FreeTubeSync.Model.Database;
+using FreeTubeSync.Model;
 using Microsoft.EntityFrameworkCore;
 
 namespace FreeTubeSync.Database;
@@ -13,10 +13,10 @@ public class DataContext : DbContext
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         modelBuilder.Entity<Profile>()
-            .Navigation(e => e.subscriptions).AutoInclude();
+            .OwnsMany<Subscription>(o => o.subscriptions);
 
         modelBuilder.Entity<Playlist>()
-            .Navigation(e => e.videos).AutoInclude();
+            .OwnsMany<Video>(o => o.videos);
     }
 
     public override int SaveChanges()
@@ -71,7 +71,5 @@ public class DataContext : DbContext
     public DbSet<Profile> Profiles { get; set; }
     public DbSet<SearchHistory> SearchHistories { get; set; }
     public DbSet<Setting> Settings { get; set; }
-    public DbSet<Subscription> Subscriptions { get; set; }
-    public DbSet<Video> Videos { get; set; }
     public DbSet<ChangeLog> ChangeLogs { get; set; }
 }

FreeTubeSync/EndPoints/HistoryEndpoint.cs

@@ -1,6 +1,4 @@
-using FreeTubeSync.Database;
+using FreeTubeSync.Model;
-using FreeTubeSync.Model.Database;
-using FreeTubeSync.Model.Json;
 
 namespace FreeTubeSync.EndPoints;
 
@@ -10,37 +8,58 @@ public static class HistoryEndpoint
     {
         var group = app.MapGroup("history");
 
-        group.MapGet("/", async (IRepository<History> repository, CancellationToken ct) =>
+        group.MapGet("/", GetAllHistory);
-        {
+        group.MapGet("/{id}", GetHistory);
-            var results = await repository.GetAllAsync(ct);
+        group.MapPost("/", UpdateHistory);
-            var jsonResults = new List<HistoryJson>();
+        group.MapDelete("/{id}", DeleteHistory);
-            results.MapTo(jsonResults);
+    }
-            return Results.Ok(jsonResults);
+    
-        });
+    private static async Task<IResult> GetAllHistory(IRepository<History> repository, CancellationToken ct)
+    {
+        var results = await repository.GetAllAsync(ct);
+        return Results.Ok(results);
+    }
 
-        group.MapPost("/", async (IRepository<History> repository, CancellationToken ct, HistoryJson historyJson) =>
+    private static async Task<IResult> GetHistory(IRepository<History> repository, string id, CancellationToken ct)
+    {
+        var result = await repository.GetByIdAsync(id, ct);
+        return result == null ? Results.NotFound() : Results.Ok(result);
+    }
+    private static async Task<IResult> UpdateHistory(IRepository<History> repository, History history, CancellationToken ct, ILogger<Program> logger)
+    {
+        var results = await repository.GetByIdAsync(history._id, ct);
+        if (results == null)
         {
-            var results = await repository.GetByIdAsync(historyJson._id, ct);
+            try
-            if (results == null)
             {
-                results = new History();
+                await repository.AddAsync(history, ct);
-                results.MapFrom(historyJson);
-                await repository.AddAsync(results, ct);
             }
-            else
+            catch (Exception ex)
             {
-                results.MapFrom(historyJson);
+                logger.LogError(ex, "Failed to create history {json}", history._id);
-                await repository.UpdateAsync(results, ct);
+                return Results.StatusCode(500);
             }
-            return Results.Ok();
+        }
-        });
+        else
+        {
+            try
+            {
+                await repository.UpdateAsync(history, ct);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to update history {json}", history._id);
+                return Results.StatusCode(500);
+            }
+        }
+        return Results.Ok();
+    }
 
-        group.MapDelete("/{id}", async (IRepository<History> repository, CancellationToken ct, string id) =>
+    private static async Task<IResult> DeleteHistory(IRepository<History> repository, string id, CancellationToken ct)
-        {
+    {
-            var result = await repository.GetByIdAsync(id, ct);
+        var result = await repository.GetByIdAsync(id, ct);
-            if (result == null) return Results.NotFound();
+        if (result == null) return Results.NotFound();
-            await repository.DeleteAsync(result, ct);
+        await repository.DeleteAsync(result, ct);
-            return Results.Ok();
+        return Results.Ok();
-        });
     }
 }

FreeTubeSync/EndPoints/PingEndpoint.cs

@@ -1,5 +1,4 @@
 using FreeTubeSync.Database;
-using FreeTubeSync.Model.Database;
 
 namespace FreeTubeSync.EndPoints;
 

FreeTubeSync/EndPoints/PlaylistEndpoint.cs

@@ -1,6 +1,4 @@
-using FreeTubeSync.Database;
+using FreeTubeSync.Model;
-using FreeTubeSync.Model.Database;
-using FreeTubeSync.Model.Json;
 
 namespace FreeTubeSync.EndPoints;
 
@@ -10,78 +8,82 @@ public static class PlaylistEndpoint
     {
         var group = app.MapGroup("playlists");
 
-        group.MapGet("/", async (IRepository<Playlist> repository, CancellationToken ct) =>
+        group.MapGet("/", GetAllPlaylists);
-        {
+        group.MapGet("/{id}", GetPlaylist);
-            var results = (await repository.GetAllAsync(ct)).ToList();
+        group.MapPost("/", UpdatePlaylist);
-            var jsonResults = new List<PlaylistJson>();
+        group.MapDelete("/{id}", RemovePlaylist);
-            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, IRepository<Video> vidRepo, CancellationToken ct, PlaylistJson playlistJson) =>
+    private static async Task<IResult> GetAllPlaylists(IRepository<Playlist> repository, CancellationToken ct)
+    {
+        var results = await repository.GetAllAsync(ct);
+        return Results.Ok(results);
+    }
+
+    private static async Task<IResult> GetPlaylist(IRepository<Playlist> repository, string id, CancellationToken ct)
+    {
+        var result = await repository.GetByIdAsync(id, ct);
+        return result == null ? Results.NotFound() : Results.Ok(result);
+    }
+
+    private static async Task<IResult> UpdatePlaylist(IRepository<Playlist> repository, Playlist playlist, CancellationToken ct,
+        ILogger<Program> logger)
+    {
+        var results = await repository.GetByIdAsync(playlist._id, ct);
+        if (results == null)
         {
-            var results = await repository.GetByIdAsync(playlistJson._id, ct);
+            try
-            if (results == null)
             {
-                results = new Playlist();
+                await repository.AddAsync(playlist, ct);
-                results.MapFrom(playlistJson);
+            }
-                foreach (var video in playlistJson.videos)
+            catch (Exception ex)
-                {
+            {
-                    var vid = new Video();
+                logger.LogError(ex, "Failed to create Playlist {playlist}", playlist._id);
-                    vid.MapFrom(video);
+                return Results.StatusCode(500);
+            }
+        }
+        else
+        {
+            // Add Update Code here
+            var toRemove = results.videos.Where(vid => !playlist.videos.Any(x => x.playlistItemId == vid.playlistItemId)).ToList();
+
+            results.lastUpdatedAt = playlist.lastUpdatedAt;
+            results.@protected = playlist.@protected;
+            results.playlistName = playlist.playlistName;
+            results.createdAt = playlist.createdAt;
+
+            foreach (var vid in toRemove)
+                results.videos.Remove(vid);
+
+            foreach (var vid in playlist.videos)
+            {
+                var ovid = results.videos.FirstOrDefault(x => x.playlistItemId == vid.playlistItemId);
+                if (ovid == null)
                     results.videos.Add(vid);
+                else
+                {
+                    ovid.videoId = vid.videoId;
+                    ovid.title = vid.title;
+                    ovid.author = vid.author;
+                    ovid.authorId = vid.authorId;
+                    ovid.lengthSeconds = vid.lengthSeconds;
+                    ovid.published = vid.published;
+                    ovid.timeAdded = vid.timeAdded;
+                    ovid.playlistItemId = vid.playlistItemId;
+                    ovid.type = vid.type;
                 }
-                await repository.AddAsync(results, ct);
             }
-            else
+            await repository.UpdateAsync(results, ct);
-            {
+        }
-                results.MapFrom(playlistJson);
 
-                var notFound = new List<Video>();
+        return Results.Ok();
-                foreach (var video in results.videos)
+    }
-                {
+    
-                    var f = playlistJson.videos.FirstOrDefault(v => video.playlistItemId == v.playlistItemId);
+    private static async Task<IResult> RemovePlaylist(IRepository<Playlist> repository, string id, CancellationToken ct)
-                    if (f == null)
+    {
-                        notFound.Add(video);
+        var result = await repository.GetByIdAsync(id, ct);
-                    else
+        if (result == null) return Results.NotFound();
-                    {
+        await repository.DeleteAsync(result, ct);
-                        video.MapFrom(f);
+        return Results.Ok();
-                    }
-                }
-
-                var newVids = (from video in playlistJson.videos
-                    let f = results.videos.FirstOrDefault(v => v.playlistItemId == video.playlistItemId)
-                    where f == null
-                    select video).ToList();
-
-                foreach (var newVid in newVids)
-                {
-                    var vres = new Video();
-                    vres.MapFrom(newVid);
-                    results.videos.Add(vres);
-                }
-
-                foreach (var nfVid in notFound)
-                {
-                    await vidRepo.DeleteAsync(nfVid, ct, false);
-                    results.videos.Remove(nfVid);
-                }
-
-                await repository.UpdateAsync(results, ct);
-            }
-
-            return Results.Ok();
-        });
-
-        group.MapDelete("/{id}", async (IRepository<Playlist> repository, CancellationToken ct, string id) =>
-        {
-            var result = await repository.GetByIdAsync(id, ct);
-            if (result == null) return Results.NotFound();
-            await repository.DeleteAsync(result, ct);
-            return Results.Ok();
-        });
     }
 }

FreeTubeSync/EndPoints/ProfileEndpoint.cs

@@ -1,6 +1,4 @@
-using FreeTubeSync.Database;
+using FreeTubeSync.Model;
-using FreeTubeSync.Model.Database;
-using FreeTubeSync.Model.Json;
 
 namespace FreeTubeSync.EndPoints;
 
@@ -10,78 +8,73 @@ public static class ProfileEndpoint
     {
         var group = app.MapGroup("profile");
 
-        group.MapGet("/", async (IRepository<Profile> repository, CancellationToken ct) =>
+        group.MapGet("/", GetAllProfiles);
-        {
+        group.MapGet("/{id}", GetProfile);
-            var results = (await repository.GetAllAsync(ct)).ToList();
+        group.MapPost("/", UpdateProfile);
-            var jsonResults = new List<ProfileJson>();
+        group.MapDelete("/{id}", DeleteProfile);
-            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, IRepository<Subscription> subRepo, CancellationToken ct, ProfileJson profileJson) =>
+    private static async Task<IResult> GetAllProfiles(IRepository<Profile> repository, CancellationToken ct)
+    {
+        var results = await repository.GetAllAsync(ct);
+        return Results.Ok(results);
+    }
+
+    private static async Task<IResult> GetProfile(IRepository<Profile> repository, string id, CancellationToken ct)
+    {
+        var result = await repository.GetByIdAsync(id, ct);
+        return result == null ? Results.NotFound() : Results.Ok(result);
+    }
+
+    private static async Task<IResult> UpdateProfile(IRepository<Profile> repository, Profile profile, CancellationToken ct, ILogger<Program> logger)
+    {
+        var res = await repository.GetByIdAsync(profile._id, ct);
+        if (res == null)
         {
-            var res = await repository.GetByIdAsync(profileJson._id, ct);
+            try
-            if (res == null)
             {
-                res = new Profile();
+                await repository.AddAsync(profile, ct);
-                res.MapFrom(profileJson);
+            }
-                await repository.AddAsync(res, ct);
+            catch (Exception ex)
-                
+            {
-                foreach (var subscription in profileJson.subscriptions)
+                logger.LogError(ex, "Failed to create profile {json}", profile._id);
-                {
+                return Results.StatusCode(500);
-                    var sub = new Subscription();
+            }
-                    sub.MapFrom(subscription);
+        }
+        else
+        {
+            var toRemove = res.subscriptions.Where(sub => !profile.subscriptions.Any(x => x.id == sub.id)).ToList();
+
+            res.name = profile.name;
+            res.textColor = profile.textColor;
+            res.bgColor = profile.bgColor;
+
+            foreach (var sub in toRemove)
+                res.subscriptions.Remove(sub);
+
+            foreach (var sub in profile.subscriptions)
+            {
+                var osub = res.subscriptions.FirstOrDefault(x => x.id == sub.id);
+                if (osub == null)
                     res.subscriptions.Add(sub);
-                }
+                else
-                await repository.AddAsync(res, ct);
-            }
-            else
-            {
-                res.MapFrom(profileJson);
-                var notFound = new List<Subscription>();
-                foreach (var subscription in res.subscriptions)
                 {
-                    var f = profileJson.subscriptions.FirstOrDefault(s => s.id == subscription.id);
+                    osub.name = sub.name;
-                    if (f == null)
+                    osub.thumbnail = sub.thumbnail;
-                        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 = new Subscription();
-                    sres.MapFrom(newSub);
-                    res.subscriptions.Add(sres);
-                }
-
-                foreach (var nfSub in notFound)
-                {
-                    await subRepo.DeleteAsync(nfSub, ct, false);
-                    res.subscriptions.Remove(nfSub);
-                }
-
-                await repository.UpdateAsync(res, ct);
             }
 
-            return Results.Ok();
+            await repository.UpdateAsync(res, ct);
-        });
+        }
 
-        group.MapDelete("/{id}", async (IRepository<Profile> repository, CancellationToken ct, string id) =>
+        return Results.Ok();
-        {
+    }
-            var result = await repository.GetByIdAsync(id, ct);
+
-            if (result == null) return Results.NotFound();
+    private static async Task<IResult> DeleteProfile(IRepository<Profile> repository, string id, CancellationToken ct)
-            await repository.DeleteAsync(result, ct);
+    {
-            return Results.Ok();
+        var result = await repository.GetByIdAsync(id, ct);
-        });
+        if (result == null) return Results.NotFound();
+        await repository.DeleteAsync(result, ct);
+        return Results.Ok();
     }
 }

FreeTubeSync/EndPoints/SearchHistoryEndpoint.cs

@@ -1,6 +1,4 @@
-using FreeTubeSync.Database;
+using FreeTubeSync.Model;
-using FreeTubeSync.Model.Database;
-using FreeTubeSync.Model.Json;
 
 namespace FreeTubeSync.EndPoints;
 
@@ -10,39 +8,61 @@ public static class SearchHistoryEndpoint
     {
         var group = app.MapGroup("searchHistory");
 
-        group.MapGet("/", async (IRepository<SearchHistory> repository, CancellationToken ct) =>
+        group.MapGet("/", GetAllSearchHistory);
-        {
+        group.MapGet("/{id}", GetSearchHistory);
-            var result = await repository.GetAllAsync(ct);
+        group.MapPost("/", UpdateSearchHistory);
-            var jsonResults = new List<SearchHistoryJson>();
+        group.MapDelete("/{id}", DeleteSearchHistory);
-            result.MapTo(jsonResults);
+    }
-            return Results.Ok(jsonResults);
-        });
 
-        group.MapPost("/", async (IRepository<SearchHistory> repository, CancellationToken ct, SearchHistoryJson historyJson) =>
+    private static async Task<IResult> GetAllSearchHistory(IRepository<SearchHistory> repository, CancellationToken ct)
+    {
+        var results = await repository.GetAllAsync(ct);
+        return Results.Ok(results);
+    }
+
+    private static async Task<IResult> GetSearchHistory(IRepository<SearchHistory> repository, string id, CancellationToken ct)
+    {
+        var result = await repository.GetByIdAsync(id, ct);
+        return result == null ? Results.NotFound() : Results.Ok(result);
+    }
+
+    private static async Task<IResult> UpdateSearchHistory(IRepository<SearchHistory> repository, SearchHistory history, CancellationToken ct,
+        ILogger<Program> logger)
+    {
+        var result = await repository.GetByIdAsync(history._id, ct);
+        if (result == null)
         {
-            var result = await repository.GetByIdAsync(historyJson._id, ct);
+            try
-            if (result == null)
             {
-                result = new SearchHistory();
+                await repository.AddAsync(history, ct);
-                result.MapFrom(historyJson);
-                await repository.AddAsync(result, ct);
             }
-            else
+            catch (Exception e)
             {
-                result.MapFrom(historyJson);
+                logger.LogError(e, "Failed to update history {json}", history._id);
-                await repository.UpdateAsync(result, ct);
+                return Results.StatusCode(500);
             }
-
+        }
-            return Results.Ok();
+        else
-        });
-
-        group.MapDelete("/{id}", async (IRepository<SearchHistory> repository, CancellationToken ct, string id) =>
         {
-            var result = await repository.GetByIdAsync(id, ct);
+            try
-            if (result == null) return Results.NotFound();
+            {
-            await repository.DeleteAsync(result, ct);
+                await repository.UpdateAsync(history, ct);
-            return Results.Ok();
+            }
+            catch (Exception e)
+            {
+                logger.LogError(e, "Failed to update history {json}", history._id);
+                return Results.StatusCode(500);
+            }
+        }
 
-        });
+        return Results.Ok();
+    }
+
+    private static async Task<IResult> DeleteSearchHistory(IRepository<SearchHistory> repository, string id, CancellationToken ct)
+    {
+        var result = await repository.GetByIdAsync(id, ct);
+        if (result == null) return Results.NotFound();
+        await repository.DeleteAsync(result, ct);
+        return Results.Ok();
     }
 }

FreeTubeSync/EndPoints/SettingEndpoint.cs

@@ -1,6 +1,4 @@
-using FreeTubeSync.Database;
+using FreeTubeSync.Model;
-using FreeTubeSync.Model.Database;
-using FreeTubeSync.Model.Json;
 
 namespace FreeTubeSync.EndPoints;
 
@@ -10,37 +8,59 @@ public static class SettingEndpoint
     {
         var group = app.MapGroup("settings");
 
-        group.MapGet("/", async (IRepository<Setting> repository, CancellationToken ct) =>
+        group.MapGet("/", GetAllSettings);
-        {
+        group.MapGet("/{id}", GetSetting);
-            var settings = await repository.GetAllAsync(ct);
+        group.MapPost("/", UpdateSetting);
-            var jsonSettings = new List<SettingJson>();
+        group.MapDelete("/{id}", DeleteSetting);
-            settings.MapTo(jsonSettings);
+    }
-            return Results.Ok(jsonSettings);
-        });
 
-        group.MapPost("/", async (IRepository<Setting> repository, CancellationToken ct, SettingJson settingJson) =>
+    private static async Task<IResult> GetAllSettings(IRepository<Setting> repository, CancellationToken ct)
-        {
+    {
-            var res = await repository.GetByIdAsync(settingJson._id, ct);
+        var settings = await repository.GetAllAsync(ct);
-            if (res == null)
+        return Results.Ok(settings);
-            {
+    }
-                res = new Setting();
-                res.MapFrom(settingJson);
-                await repository.AddAsync(res, ct);
-            }
-            else
-            {
-                res.MapFrom(settingJson);
-                await repository.UpdateAsync(res, ct);
-            }
-            return Results.Ok();
-        });
 
-        group.MapDelete("/{id}", async (IRepository<Setting> repository, CancellationToken ct, string id) =>
+    private static async Task<IResult> GetSetting(IRepository<Setting> repository, string id, CancellationToken ct)
+    {
+        var result = await repository.GetByIdAsync(id, ct);
+        return result == null ? Results.NotFound() : Results.Ok(result);
+    }
+
+    private static async Task<IResult> UpdateSetting(IRepository<Setting> repository, Setting setting, CancellationToken ct, ILogger<Program> logger)
+    {
+        var res = await repository.GetByIdAsync(setting._id, ct);
+        if (res == null)
         {
-            var result = await repository.GetByIdAsync(id, ct);
+            try
-            if (result == null) return Results.NotFound();
+            {
-            await repository.DeleteAsync(result, ct);
+                await repository.AddAsync(setting, ct);
-            return Results.Ok();
+            }
-        });
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to add setting {setting}",  setting._id);
+                return Results.StatusCode(500);
+            }
+        }
+        else
+        {
+            try
+            {
+                await repository.UpdateAsync(setting, ct);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to update setting {setting}", setting._id);
+                return Results.StatusCode(500);
+            }
+        }
+        return Results.Ok();
+    }
+
+    private static async Task<IResult> DeleteSetting(IRepository<Setting> repository, string id, CancellationToken ct)
+    {
+        var result = await repository.GetByIdAsync(id, ct);
+        if (result == null) return Results.NotFound();
+        await repository.DeleteAsync(result, ct);
+        return Results.Ok();
     }
 }

FreeTubeSync/Model/ChangeLog.cs

@@ -1,4 +1,4 @@
-namespace FreeTubeSync.Model.Database;
+namespace FreeTubeSync.Model;
 
 public class ChangeLog
 {

FreeTubeSync/Model/History.cs

@@ -1,6 +1,6 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace FreeTubeSync.Model.Database;
+namespace FreeTubeSync.Model;
 
 public class History
 {

FreeTubeSync/Model/Json/HistoryJson.cs

@@ -1,23 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace FreeTubeSync.Model.Json;
-
-[SuppressMessage("ReSharper", "InconsistentNaming")]
-public class HistoryJson
-{
-    public string _id { get; set; } = string.Empty;
-    public string videoId { get; set; } = string.Empty;
-    public string title { get; set; } = string.Empty;
-    public string author { get; set; } = string.Empty;
-    public string authorId { get; set; } = string.Empty;
-    public long published { get; set; }
-    public string description { get; set; } = string.Empty;
-    public long viewCount { get; set; }
-    public long lengthSeconds { get; set; }
-    public float watchProgress { get; set; }
-    public long timeWatched { get; set; }
-    public bool isLive { get; set; }
-    public string type { get; set; } = string.Empty;
-    public string lastViewedPlaylistType { get; set; } = string.Empty;
-    public string? lastViewedPlaylistItemId { get; set; }
-}

FreeTubeSync/Model/Json/PlaylistJson.cs

@@ -1,14 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace FreeTubeSync.Model.Json;
-
-[SuppressMessage("ReSharper", "InconsistentNaming")]
-public class PlaylistJson
-{
-    public string _id { get; set; } = string.Empty;
-    public string playlistName { get; set; } = string.Empty;
-    public bool @protected { get; set; }
-    public List<VideoJson> videos { get; set; } = [];
-    public long createdAt { get; set; }
-    public long lastUpdatedAt { get; set; }
-}

FreeTubeSync/Model/Json/ProfileJson.cs

@@ -1,13 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace FreeTubeSync.Model.Json;
-
-[SuppressMessage("ReSharper", "InconsistentNaming")]
-public class ProfileJson
-{
-    public string _id { get; set; } = string.Empty;
-    public string name { get; set; } = string.Empty;
-    public string bgColor { get; set; } = string.Empty;
-    public string textColor { get; set; } = string.Empty;
-    public List<SubscriptionJson> subscriptions { get; set; } = [];
-}

FreeTubeSync/Model/Json/SearchHistoryJson.cs

@@ -1,10 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace FreeTubeSync.Model.Json;
-
-[SuppressMessage("ReSharper", "InconsistentNaming")]
-public class SearchHistoryJson
-{
-    public string _id { get; set; } = string.Empty;
-    public long lastUpdatedAt { get; set; }
-}

FreeTubeSync/Model/Json/SettingJson.cs

@@ -1,10 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace FreeTubeSync.Model.Json;
-
-[SuppressMessage("ReSharper", "InconsistentNaming")]
-public class SettingJson
-{
-    public string _id { get; set; } = string.Empty;
-    public string value { get; set; } 
-}

FreeTubeSync/Model/Json/SubscriptionJson.cs

@@ -1,11 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace FreeTubeSync.Model.Json;
-
-[SuppressMessage("ReSharper", "InconsistentNaming")]
-public class SubscriptionJson
-{
-    public string id { get; set; } = string.Empty;
-    public string name { get; set; } = string.Empty;
-    public string? thumbnail { get; set; }
-}

FreeTubeSync/Model/Json/VideoJson.cs

@@ -1,18 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace FreeTubeSync.Model.Json;
-
-[SuppressMessage("ReSharper", "InconsistentNaming")]
-public class VideoJson
-{
-    public string videoId { get; set; } = string.Empty;
-    public string title { get; set; } = string.Empty;
-    public string author { get; set; } = string.Empty;
-    public string authorId { get; set; } = string.Empty;
-    public string lengthSeconds { get; set; } = string.Empty;
-    public long pubished { get; set; }
-    public long timeAdded { get; set; }
-    public string playlistItemId { get; set; } = string.Empty;
-    public string type { get; set; } = string.Empty;
-
-}

FreeTubeSync/Model/Playlist.cs

@@ -1,6 +1,6 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace FreeTubeSync.Model.Database;
+namespace FreeTubeSync.Model;
 
 public class Playlist
 {

FreeTubeSync/Model/Profile.cs

@@ -1,6 +1,6 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace FreeTubeSync.Model.Database;
+namespace FreeTubeSync.Model;
 
 public class Profile
 {

FreeTubeSync/Model/SearchHistory.cs

@@ -1,6 +1,6 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace FreeTubeSync.Model.Database;
+namespace FreeTubeSync.Model;
 
 public class SearchHistory
 {

FreeTubeSync/Model/Setting.cs

@@ -1,6 +1,6 @@
 using System.ComponentModel.DataAnnotations;
 
-namespace FreeTubeSync.Model.Database;
+namespace FreeTubeSync.Model;
 
 public class Setting
 {

FreeTubeSync/Model/Subscription.cs

@@ -1,10 +1,10 @@
-using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
 
-namespace FreeTubeSync.Model.Database;
+namespace FreeTubeSync.Model;
 
+[Owned]
 public class Subscription
 {
-    [Key]
     public string id { get; set; } = string.Empty;
     public string name { get; set; } = string.Empty;
     public string? thumbnail { get; set; }

FreeTubeSync/Model/Video.cs

@@ -1,7 +1,8 @@
-using System.ComponentModel.DataAnnotations;
+using Microsoft.EntityFrameworkCore;
 
-namespace FreeTubeSync.Model.Database;
+namespace FreeTubeSync.Model;
 
+[Owned]
 public class Video
 {
     public string videoId { get; set; } = string.Empty;
@@ -9,9 +10,8 @@ public class Video
     public string author { get; set; } = string.Empty;
     public string authorId { get; set; } = string.Empty;
     public string lengthSeconds { get; set; } = string.Empty;
-    public long pubished { get; set; }
+    public long published { get; set; }
     public long timeAdded { get; set; }
-    [Key]
     public string playlistItemId { get; set; } = string.Empty;
     public string type { get; set; } = string.Empty;
 }

FreeTubeSync/Repository.cs

@@ -3,36 +3,46 @@ using Microsoft.EntityFrameworkCore;
 
 namespace FreeTubeSync;
 
-public class Repository<TEntity>(DataContext dbContext) : IRepository<TEntity> where TEntity : class
+public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
 {
+    private readonly DataContext _context;
+    private readonly DbSet<TEntity> _dbSet;
+
+    public Repository(DataContext context)
+    {
+        _context = context;
+        _dbSet = _context.Set<TEntity>();
+    }
+    
     public async Task AddAsync(TEntity entity, CancellationToken ct, bool sync = true)
     {
-        dbContext.Set<TEntity>().Add(entity);
+        _dbSet.Add(entity);
         if(sync)
-            await dbContext.SaveChangesAsync(ct);
+            await _context.SaveChangesAsync(ct);
     }
 
     public async Task UpdateAsync(TEntity entity, CancellationToken ct, bool sync = true)
     {
-        dbContext.Set<TEntity>().Update(entity);
+        _dbSet.Attach(entity);
+        _context.Entry(entity).State = EntityState.Modified;
         if (sync)
-            await dbContext.SaveChangesAsync(ct);
+            await _context.SaveChangesAsync(ct);
     }
 
     public async Task DeleteAsync(TEntity entity, CancellationToken ct, bool sync = true)
     {
-        dbContext.Set<TEntity>().Remove(entity);
+        _dbSet.Remove(entity);
         if (sync)
-            await dbContext.SaveChangesAsync(ct);
+            await _context.SaveChangesAsync(ct);
     }
 
     public async Task<TEntity?> GetByIdAsync(string id, CancellationToken ct)
     {
-        return await dbContext.Set<TEntity>().FindAsync(id, ct);
+        return await _dbSet.FindAsync(id, ct);
     }
 
     public async Task<IEnumerable<TEntity>> GetAllAsync(CancellationToken ct)
     {
-        return await dbContext.Set<TEntity>().ToListAsync<TEntity>(ct);
+        return await _dbSet.ToListAsync<TEntity>(ct);
     }
 }