Cleaning up every repository's edit & adding resetOld

Kyoo.CommonAPI/LocalRepository.cs

@@ -162,14 +162,12 @@ namespace Kyoo.Controllers
 			try
 			{
 				T old = await GetWithTracking(edited.ID);
-
 				if (old == null)
 					throw new ItemNotFound($"No resource found with the ID {edited.ID}.");
 				
-			
-				await EditRelations(old, edited);
 				if (resetOld)
 					Utility.Nullify(old);
+				await EditRelations(old, edited, resetOld);
 				Utility.Complete(old, edited, x => x.GetCustomAttribute<LoadableRelationAttribute>() == null);
 				await Validate(old);
 				await Database.SaveChangesAsync();
@@ -181,7 +179,7 @@ namespace Kyoo.Controllers
 			}
 		}
 		
-		protected virtual Task EditRelations(T resource, T changed)
+		protected virtual Task EditRelations(T resource, T changed, bool resetOld)
 		{
 			return Validate(resource);
 		}

Kyoo/Controllers/Repositories/EpisodeRepository.cs

@@ -153,33 +153,45 @@ namespace Kyoo.Controllers
 		{
 			await base.Create(obj);
 			_database.Entry(obj).State = EntityState.Added;
-			obj.Tracks = await obj.Tracks.SelectAsync(x => _tracks.CreateIfNotExists(x, true)).ToListAsync();
 			obj.ExternalIDs.ForEach(x => _database.Entry(x).State = EntityState.Added);
 			await _database.SaveChangesAsync($"Trying to insert a duplicated episode (slug {obj.Slug} already exists).");
+			obj.Tracks = await obj.Tracks.SelectAsync(x =>
+			{
+				x.Episode = obj;
+				x.EpisodeID = obj.ID;
+				return _tracks.CreateIfNotExists(x, true);
+			}).ToListAsync();
 			return obj;
 		}
 
-		protected override async Task EditRelations(Episode resource, Episode changed)
+		protected override async Task EditRelations(Episode resource, Episode changed, bool resetOld)
 		{
 			if (resource.ShowID <= 0)
 				throw new InvalidOperationException($"Can't store an episode not related to any show (showID: {resource.ShowID}).");
 
-			await base.EditRelations(resource, changed);
+			await base.EditRelations(resource, changed, resetOld);
 
-			ICollection<Track> oldTracks = resource.Tracks;
+			if (changed.Tracks != null || resetOld)
-			resource.Tracks = await changed.Tracks.SelectAsync(async track =>
+			{
-				{
+				ICollection<Track> oldTracks = await _tracks.GetAll(x => x.EpisodeID == resource.ID);
-					Track oldValue = oldTracks?.FirstOrDefault(x => Utility.ResourceEquals(track, x));
+				resource.Tracks = await changed.Tracks.SelectAsync(async track =>
-					if (oldValue == null)
+					{
-						return await _tracks.CreateIfNotExists(track, true);
+						Track oldValue = oldTracks?.FirstOrDefault(x => Utility.ResourceEquals(track, x));
-					oldTracks.Remove(oldValue);
+						if (oldValue == null)
-					return oldValue;
+							return await _tracks.CreateIfNotExists(track, true);
-				})
+						oldTracks.Remove(oldValue);
-				.ToListAsync();
+						return oldValue;
-			foreach (Track x in oldTracks)
+					})
-				await _tracks.Delete(x);
+					.ToListAsync();
+				foreach (Track x in oldTracks)
+					await _tracks.Delete(x);
+			}
 
-			resource.ExternalIDs = changed.ExternalIDs;
+			if (changed.ExternalIDs != null || resetOld)
+			{
+				await Database.Entry(resource).Collection(x => x.ExternalIDs).LoadAsync();
+				resource.ExternalIDs = changed.ExternalIDs;
+			}
 		}
 
 		protected override async Task Validate(Episode resource)

Kyoo/Controllers/Repositories/LibraryItemRepository.cs

@@ -110,7 +110,6 @@ namespace Kyoo.Controllers
 			throw new InvalidOperationException();
 		}
 		public override Task<LibraryItem> Edit(LibraryItem obj, bool reset) => throw new InvalidOperationException();
-		protected override Task EditRelations(LibraryItem _, LibraryItem changed) => throw new InvalidOperationException();
 		public override Task Delete(int id) => throw new InvalidOperationException();
 		public override Task Delete(string slug) => throw new InvalidOperationException();
 		public override Task Delete(LibraryItem obj) => throw new InvalidOperationException();

Kyoo/Controllers/Repositories/LibraryRepository.cs

@@ -69,7 +69,7 @@ namespace Kyoo.Controllers
 				.ToListAsync();
 		}
 
-		protected override Task EditRelations(Library resource, Library changed)
+		protected override async Task EditRelations(Library resource, Library changed, bool resetOld)
 		{
 			if (string.IsNullOrEmpty(resource.Slug))
 				throw new ArgumentException("The library's slug must be set and not empty");
@@ -78,7 +78,10 @@ namespace Kyoo.Controllers
 			if (resource.Paths == null || !resource.Paths.Any())
 				throw new ArgumentException("The library should have a least one path.");
 
-			return base.EditRelations(resource, changed);
+			if (changed.Providers != null || resetOld)
+				await Database.Entry(resource).Collection(x => x.Providers).LoadAsync();
+			resource.Providers = changed.Providers;
+			await base.EditRelations(resource, changed, resetOld);
 		}
 
 		public override async Task Delete(Library obj)

Kyoo/Controllers/Repositories/PeopleRepository.cs

@@ -77,11 +77,15 @@ namespace Kyoo.Controllers
 				role.Show = await _shows.Value.CreateIfNotExists(role.Show, true));
 		}
 
-		protected override async Task EditRelations(People resource, People changed)
+		protected override async Task EditRelations(People resource, People changed, bool resetOld)
 		{
-			await base.EditRelations(resource, changed);
+			if (changed.Roles != null || resetOld)
+				await Database.Entry(resource).Collection(x => x.Roles).LoadAsync();
 			resource.Roles = changed.Roles;
+			if (changed.ExternalIDs != null || resetOld)
+				await Database.Entry(resource).Collection(x => x.ExternalIDs).LoadAsync();
 			resource.ExternalIDs = changed.ExternalIDs;
+			await base.EditRelations(resource, changed, resetOld);
 		}
 
 		public override async Task Delete(People obj)

Kyoo/Controllers/Repositories/SeasonRepository.cs

@@ -142,10 +142,12 @@ namespace Kyoo.Controllers
 				id.Provider = await _providers.CreateIfNotExists(id.Provider, true));
 		}
 
-		protected override Task EditRelations(Season resource, Season changed)
+		protected override async Task EditRelations(Season resource, Season changed, bool resetOld)
 		{
+			if (changed.ExternalIDs != null || resetOld)
+				await Database.Entry(resource).Collection(x => x.ExternalIDs).LoadAsync();
 			resource.ExternalIDs = changed.ExternalIDs;
-			return base.EditRelations(resource, changed);
+			await base.EditRelations(resource, changed, resetOld);
 		}
 
 		public async Task Delete(string showSlug, int seasonNumber)

Kyoo/Controllers/Repositories/ShowRepository.cs

@@ -99,26 +99,33 @@ namespace Kyoo.Controllers
 		protected override async Task Validate(Show resource)
 		{
 			await base.Validate(resource);
+			resource.Studio = await _studios.CreateIfNotExists(resource.Studio, true);
+			resource.Genres = await resource.Genres
+				.SelectAsync(x => _genres.CreateIfNotExists(x, true))
+				.ToListAsync();
+			await resource.ExternalIDs.ForEachAsync(async id => 
+				id.Provider = await _providers.CreateIfNotExists(id.Provider, true));
+			await resource.People.ForEachAsync(async role =>
+				role.People = await _people.CreateIfNotExists(role.People, true));
+		}
 
-			if (ShouldValidate(resource.Studio))
+		protected override async Task EditRelations(Show resource, Show changed, bool resetOld)
-				resource.Studio = await _studios.CreateIfNotExists(resource.Studio, true);
+		{
+			if (changed.Aliases != null || resetOld)
+				resource.Aliases = changed.Aliases;
 			
-			if (resource.Genres != null)
+			if (changed.Genres != null || resetOld)
-			{
+				await Database.Entry(resource).Collection(x => x.Genres).LoadAsync();
-				resource.Genres = await resource.Genres
+			resource.Genres = changed.Genres;
-					.SelectAsync(x => _genres.CreateIfNotExists(x, true))
-					.ToListAsync();
-			}
 			
-			if (resource.People != null)
+			if (changed.People != null || resetOld)
-				foreach (PeopleRole link in resource.People)
+				await Database.Entry(resource).Collection(x => x.People).LoadAsync();
-					if (ShouldValidate(link))
+			resource.People = changed.People;
-						link.People = await _people.CreateIfNotExists(link.People, true);
 			
-			if (resource.ExternalIDs != null)
+			if (changed.ExternalIDs != null || resetOld)
-				foreach (MetadataID link in resource.ExternalIDs)
+				await Database.Entry(resource).Collection(x => x.ExternalIDs).LoadAsync();
-					if (ShouldValidate(link))
+			resource.ExternalIDs = changed.ExternalIDs;
-						link.Provider = await _providers.CreateIfNotExists(link.Provider, true);
+			await base.EditRelations(resource, changed, resetOld);
 		}
 
 		public async Task AddShowLink(int showID, int? libraryID, int? collectionID)

Kyoo/Controllers/Repositories/StudioRepository.cs

@@ -42,10 +42,6 @@ namespace Kyoo.Controllers
 				throw new ArgumentNullException(nameof(obj));
 			
 			_database.Entry(obj).State = EntityState.Deleted;
-			
-			// Using Dotnet-EF change discovery service to remove references to this studio on shows.
-			foreach (Show show in obj.Shows)
-				show.StudioID = null;
 			await _database.SaveChangesAsync();
 		}
 	}

Kyoo/Controllers/Repositories/TrackRepository.cs

@@ -98,13 +98,6 @@ namespace Kyoo.Controllers
 			return obj;
 		}
 
-		
-		
-		protected override Task Validate(Track resource)
-		{
-			return Task.CompletedTask;
-		}
-		
 		public override async Task Delete(Track obj)
 		{
 			if (obj == null)

Kyoo/Models/DatabaseMigrations/Internal/20210316095337_Initial.Designer.cs

@@ -0,0 +1,778 @@
+// <auto-generated />
+using System;
+using Kyoo;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace Kyoo.Models.DatabaseMigrations.Internal
+{
+    [DbContext(typeof(DatabaseContext))]
+    [Migration("20210316095337_Initial")]
+    partial class Initial
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasPostgresEnum(null, "item_type", new[] { "show", "movie", "collection" })
+                .HasPostgresEnum(null, "status", new[] { "finished", "airing", "planned", "unknown" })
+                .HasPostgresEnum(null, "stream_type", new[] { "unknown", "video", "audio", "subtitle", "font" })
+                .HasAnnotation("Relational:MaxIdentifierLength", 63)
+                .HasAnnotation("ProductVersion", "5.0.3")
+                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            modelBuilder.Entity("Kyoo.Models.Collection", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Collections");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Episode", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("AbsoluteNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EpisodeNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int>("Runtime")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SeasonID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SeasonNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShowID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Thumb")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("SeasonID");
+
+                    b.HasIndex("ShowID", "SeasonNumber", "EpisodeNumber", "AbsoluteNumber")
+                        .IsUnique();
+
+                    b.ToTable("Episodes");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Genre", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Genres");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Library", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string[]>("Paths")
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Libraries");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Collection, Kyoo.Models.Show>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Collection, Show>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.Collection>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Library, Collection>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.ProviderID>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Library, ProviderID>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.Show>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Library, Show>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Show, Kyoo.Models.Genre>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Show, Genre>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.MetadataID", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("DataID")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EpisodeID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Link")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PeopleID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProviderID")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SeasonID")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ShowID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("EpisodeID");
+
+                    b.HasIndex("PeopleID");
+
+                    b.HasIndex("ProviderID");
+
+                    b.HasIndex("SeasonID");
+
+                    b.HasIndex("ShowID");
+
+                    b.ToTable("MetadataIds");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.People", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("People");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.PeopleRole", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("PeopleID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ShowID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("PeopleID");
+
+                    b.HasIndex("ShowID");
+
+                    b.ToTable("PeopleRoles");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.ProviderID", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Logo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Providers");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Season", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("text");
+
+                    b.Property<int>("SeasonNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShowID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("ShowID", "SeasonNumber")
+                        .IsUnique();
+
+                    b.ToTable("Seasons");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Show", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string[]>("Aliases")
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Backdrop")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EndYear")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsMovie")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Logo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("StartYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("StudioID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TrailerUrl")
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.HasIndex("StudioID");
+
+                    b.ToTable("Shows");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Studio", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Studios");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Track", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("text");
+
+                    b.Property<int>("EpisodeID")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsExternal")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsForced")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("EpisodeID");
+
+                    b.ToTable("Tracks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Episode", b =>
+                {
+                    b.HasOne("Kyoo.Models.Season", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonID");
+
+                    b.HasOne("Kyoo.Models.Show", "Show")
+                        .WithMany("Episodes")
+                        .HasForeignKey("ShowID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Collection, Kyoo.Models.Show>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Collection", "First")
+                        .WithMany("ShowLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Show", "Second")
+                        .WithMany("CollectionLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.Collection>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Library", "First")
+                        .WithMany("CollectionLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Collection", "Second")
+                        .WithMany("LibraryLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.ProviderID>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Library", "First")
+                        .WithMany("ProviderLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.ProviderID", "Second")
+                        .WithMany("LibraryLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.Show>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Library", "First")
+                        .WithMany("ShowLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Show", "Second")
+                        .WithMany("LibraryLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Show, Kyoo.Models.Genre>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Show", "First")
+                        .WithMany("GenreLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Genre", "Second")
+                        .WithMany("ShowLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.MetadataID", b =>
+                {
+                    b.HasOne("Kyoo.Models.Episode", "Episode")
+                        .WithMany("ExternalIDs")
+                        .HasForeignKey("EpisodeID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Kyoo.Models.People", "People")
+                        .WithMany("ExternalIDs")
+                        .HasForeignKey("PeopleID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Kyoo.Models.ProviderID", "Provider")
+                        .WithMany("MetadataLinks")
+                        .HasForeignKey("ProviderID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Season", "Season")
+                        .WithMany("ExternalIDs")
+                        .HasForeignKey("SeasonID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Kyoo.Models.Show", "Show")
+                        .WithMany("ExternalIDs")
+                        .HasForeignKey("ShowID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Episode");
+
+                    b.Navigation("People");
+
+                    b.Navigation("Provider");
+
+                    b.Navigation("Season");
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.PeopleRole", b =>
+                {
+                    b.HasOne("Kyoo.Models.People", "People")
+                        .WithMany("Roles")
+                        .HasForeignKey("PeopleID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Show", "Show")
+                        .WithMany("People")
+                        .HasForeignKey("ShowID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("People");
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Season", b =>
+                {
+                    b.HasOne("Kyoo.Models.Show", "Show")
+                        .WithMany("Seasons")
+                        .HasForeignKey("ShowID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Show", b =>
+                {
+                    b.HasOne("Kyoo.Models.Studio", "Studio")
+                        .WithMany("Shows")
+                        .HasForeignKey("StudioID");
+
+                    b.Navigation("Studio");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Track", b =>
+                {
+                    b.HasOne("Kyoo.Models.Episode", "Episode")
+                        .WithMany("Tracks")
+                        .HasForeignKey("EpisodeID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Episode");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Collection", b =>
+                {
+                    b.Navigation("LibraryLinks");
+
+                    b.Navigation("ShowLinks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Episode", b =>
+                {
+                    b.Navigation("ExternalIDs");
+
+                    b.Navigation("Tracks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Genre", b =>
+                {
+                    b.Navigation("ShowLinks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Library", b =>
+                {
+                    b.Navigation("CollectionLinks");
+
+                    b.Navigation("ProviderLinks");
+
+                    b.Navigation("ShowLinks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.People", b =>
+                {
+                    b.Navigation("ExternalIDs");
+
+                    b.Navigation("Roles");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.ProviderID", b =>
+                {
+                    b.Navigation("LibraryLinks");
+
+                    b.Navigation("MetadataLinks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Season", b =>
+                {
+                    b.Navigation("Episodes");
+
+                    b.Navigation("ExternalIDs");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Show", b =>
+                {
+                    b.Navigation("CollectionLinks");
+
+                    b.Navigation("Episodes");
+
+                    b.Navigation("ExternalIDs");
+
+                    b.Navigation("GenreLinks");
+
+                    b.Navigation("LibraryLinks");
+
+                    b.Navigation("People");
+
+                    b.Navigation("Seasons");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Studio", b =>
+                {
+                    b.Navigation("Shows");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Kyoo/Models/DatabaseMigrations/Internal/20210316095337_Initial.cs

@@ -0,0 +1,604 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace Kyoo.Models.DatabaseMigrations.Internal
+{
+    public partial class Initial : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AlterDatabase()
+                .Annotation("Npgsql:Enum:item_type", "show,movie,collection")
+                .Annotation("Npgsql:Enum:status", "finished,airing,planned,unknown")
+                .Annotation("Npgsql:Enum:stream_type", "unknown,video,audio,subtitle,font");
+
+            migrationBuilder.CreateTable(
+                name: "Collections",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Slug = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: true),
+                    Poster = table.Column<string>(type: "text", nullable: true),
+                    Overview = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Collections", x => x.ID);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Genres",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Slug = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Genres", x => x.ID);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Libraries",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Slug = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: true),
+                    Paths = table.Column<string[]>(type: "text[]", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Libraries", x => x.ID);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "People",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Slug = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: true),
+                    Poster = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_People", x => x.ID);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Providers",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Slug = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: true),
+                    Logo = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Providers", x => x.ID);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Studios",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Slug = table.Column<string>(type: "text", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Studios", x => x.ID);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Link<Library, Collection>",
+                columns: table => new
+                {
+                    FirstID = table.Column<int>(type: "integer", nullable: false),
+                    SecondID = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Link<Library, Collection>", x => new { x.FirstID, x.SecondID });
+                    table.ForeignKey(
+                        name: "FK_Link<Library, Collection>_Collections_SecondID",
+                        column: x => x.SecondID,
+                        principalTable: "Collections",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Link<Library, Collection>_Libraries_FirstID",
+                        column: x => x.FirstID,
+                        principalTable: "Libraries",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Link<Library, ProviderID>",
+                columns: table => new
+                {
+                    FirstID = table.Column<int>(type: "integer", nullable: false),
+                    SecondID = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Link<Library, ProviderID>", x => new { x.FirstID, x.SecondID });
+                    table.ForeignKey(
+                        name: "FK_Link<Library, ProviderID>_Libraries_FirstID",
+                        column: x => x.FirstID,
+                        principalTable: "Libraries",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Link<Library, ProviderID>_Providers_SecondID",
+                        column: x => x.SecondID,
+                        principalTable: "Providers",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Shows",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Slug = table.Column<string>(type: "text", nullable: false),
+                    Title = table.Column<string>(type: "text", nullable: true),
+                    Aliases = table.Column<string[]>(type: "text[]", nullable: true),
+                    Path = table.Column<string>(type: "text", nullable: true),
+                    Overview = table.Column<string>(type: "text", nullable: true),
+                    Status = table.Column<int>(type: "integer", nullable: true),
+                    TrailerUrl = table.Column<string>(type: "text", nullable: true),
+                    StartYear = table.Column<int>(type: "integer", nullable: true),
+                    EndYear = table.Column<int>(type: "integer", nullable: true),
+                    Poster = table.Column<string>(type: "text", nullable: true),
+                    Logo = table.Column<string>(type: "text", nullable: true),
+                    Backdrop = table.Column<string>(type: "text", nullable: true),
+                    IsMovie = table.Column<bool>(type: "boolean", nullable: false),
+                    StudioID = table.Column<int>(type: "integer", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Shows", x => x.ID);
+                    table.ForeignKey(
+                        name: "FK_Shows_Studios_StudioID",
+                        column: x => x.StudioID,
+                        principalTable: "Studios",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Link<Collection, Show>",
+                columns: table => new
+                {
+                    FirstID = table.Column<int>(type: "integer", nullable: false),
+                    SecondID = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Link<Collection, Show>", x => new { x.FirstID, x.SecondID });
+                    table.ForeignKey(
+                        name: "FK_Link<Collection, Show>_Collections_FirstID",
+                        column: x => x.FirstID,
+                        principalTable: "Collections",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Link<Collection, Show>_Shows_SecondID",
+                        column: x => x.SecondID,
+                        principalTable: "Shows",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Link<Library, Show>",
+                columns: table => new
+                {
+                    FirstID = table.Column<int>(type: "integer", nullable: false),
+                    SecondID = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Link<Library, Show>", x => new { x.FirstID, x.SecondID });
+                    table.ForeignKey(
+                        name: "FK_Link<Library, Show>_Libraries_FirstID",
+                        column: x => x.FirstID,
+                        principalTable: "Libraries",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Link<Library, Show>_Shows_SecondID",
+                        column: x => x.SecondID,
+                        principalTable: "Shows",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Link<Show, Genre>",
+                columns: table => new
+                {
+                    FirstID = table.Column<int>(type: "integer", nullable: false),
+                    SecondID = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Link<Show, Genre>", x => new { x.FirstID, x.SecondID });
+                    table.ForeignKey(
+                        name: "FK_Link<Show, Genre>_Genres_SecondID",
+                        column: x => x.SecondID,
+                        principalTable: "Genres",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_Link<Show, Genre>_Shows_FirstID",
+                        column: x => x.FirstID,
+                        principalTable: "Shows",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "PeopleRoles",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    PeopleID = table.Column<int>(type: "integer", nullable: false),
+                    ShowID = table.Column<int>(type: "integer", nullable: false),
+                    Role = table.Column<string>(type: "text", nullable: true),
+                    Type = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PeopleRoles", x => x.ID);
+                    table.ForeignKey(
+                        name: "FK_PeopleRoles_People_PeopleID",
+                        column: x => x.PeopleID,
+                        principalTable: "People",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_PeopleRoles_Shows_ShowID",
+                        column: x => x.ShowID,
+                        principalTable: "Shows",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Seasons",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ShowID = table.Column<int>(type: "integer", nullable: false),
+                    SeasonNumber = table.Column<int>(type: "integer", nullable: false),
+                    Title = table.Column<string>(type: "text", nullable: true),
+                    Overview = table.Column<string>(type: "text", nullable: true),
+                    Year = table.Column<int>(type: "integer", nullable: true),
+                    Poster = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Seasons", x => x.ID);
+                    table.ForeignKey(
+                        name: "FK_Seasons_Shows_ShowID",
+                        column: x => x.ShowID,
+                        principalTable: "Shows",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Episodes",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ShowID = table.Column<int>(type: "integer", nullable: false),
+                    SeasonID = table.Column<int>(type: "integer", nullable: true),
+                    SeasonNumber = table.Column<int>(type: "integer", nullable: false),
+                    EpisodeNumber = table.Column<int>(type: "integer", nullable: false),
+                    AbsoluteNumber = table.Column<int>(type: "integer", nullable: false),
+                    Path = table.Column<string>(type: "text", nullable: true),
+                    Thumb = table.Column<string>(type: "text", nullable: true),
+                    Title = table.Column<string>(type: "text", nullable: true),
+                    Overview = table.Column<string>(type: "text", nullable: true),
+                    ReleaseDate = table.Column<DateTime>(type: "timestamp without time zone", nullable: true),
+                    Runtime = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Episodes", x => x.ID);
+                    table.ForeignKey(
+                        name: "FK_Episodes_Seasons_SeasonID",
+                        column: x => x.SeasonID,
+                        principalTable: "Seasons",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_Episodes_Shows_ShowID",
+                        column: x => x.ShowID,
+                        principalTable: "Shows",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "MetadataIds",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ProviderID = table.Column<int>(type: "integer", nullable: false),
+                    ShowID = table.Column<int>(type: "integer", nullable: true),
+                    EpisodeID = table.Column<int>(type: "integer", nullable: true),
+                    SeasonID = table.Column<int>(type: "integer", nullable: true),
+                    PeopleID = table.Column<int>(type: "integer", nullable: true),
+                    DataID = table.Column<string>(type: "text", nullable: true),
+                    Link = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_MetadataIds", x => x.ID);
+                    table.ForeignKey(
+                        name: "FK_MetadataIds_Episodes_EpisodeID",
+                        column: x => x.EpisodeID,
+                        principalTable: "Episodes",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MetadataIds_People_PeopleID",
+                        column: x => x.PeopleID,
+                        principalTable: "People",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MetadataIds_Providers_ProviderID",
+                        column: x => x.ProviderID,
+                        principalTable: "Providers",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MetadataIds_Seasons_SeasonID",
+                        column: x => x.SeasonID,
+                        principalTable: "Seasons",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_MetadataIds_Shows_ShowID",
+                        column: x => x.ShowID,
+                        principalTable: "Shows",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Tracks",
+                columns: table => new
+                {
+                    ID = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    EpisodeID = table.Column<int>(type: "integer", nullable: false),
+                    IsDefault = table.Column<bool>(type: "boolean", nullable: false),
+                    IsForced = table.Column<bool>(type: "boolean", nullable: false),
+                    IsExternal = table.Column<bool>(type: "boolean", nullable: false),
+                    Title = table.Column<string>(type: "text", nullable: true),
+                    Language = table.Column<string>(type: "text", nullable: true),
+                    Codec = table.Column<string>(type: "text", nullable: true),
+                    Path = table.Column<string>(type: "text", nullable: true),
+                    Type = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Tracks", x => x.ID);
+                    table.ForeignKey(
+                        name: "FK_Tracks_Episodes_EpisodeID",
+                        column: x => x.EpisodeID,
+                        principalTable: "Episodes",
+                        principalColumn: "ID",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Collections_Slug",
+                table: "Collections",
+                column: "Slug",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Episodes_SeasonID",
+                table: "Episodes",
+                column: "SeasonID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Episodes_ShowID_SeasonNumber_EpisodeNumber_AbsoluteNumber",
+                table: "Episodes",
+                columns: new[] { "ShowID", "SeasonNumber", "EpisodeNumber", "AbsoluteNumber" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Genres_Slug",
+                table: "Genres",
+                column: "Slug",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Libraries_Slug",
+                table: "Libraries",
+                column: "Slug",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Link<Collection, Show>_SecondID",
+                table: "Link<Collection, Show>",
+                column: "SecondID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Link<Library, Collection>_SecondID",
+                table: "Link<Library, Collection>",
+                column: "SecondID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Link<Library, ProviderID>_SecondID",
+                table: "Link<Library, ProviderID>",
+                column: "SecondID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Link<Library, Show>_SecondID",
+                table: "Link<Library, Show>",
+                column: "SecondID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Link<Show, Genre>_SecondID",
+                table: "Link<Show, Genre>",
+                column: "SecondID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MetadataIds_EpisodeID",
+                table: "MetadataIds",
+                column: "EpisodeID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MetadataIds_PeopleID",
+                table: "MetadataIds",
+                column: "PeopleID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MetadataIds_ProviderID",
+                table: "MetadataIds",
+                column: "ProviderID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MetadataIds_SeasonID",
+                table: "MetadataIds",
+                column: "SeasonID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_MetadataIds_ShowID",
+                table: "MetadataIds",
+                column: "ShowID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_People_Slug",
+                table: "People",
+                column: "Slug",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PeopleRoles_PeopleID",
+                table: "PeopleRoles",
+                column: "PeopleID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PeopleRoles_ShowID",
+                table: "PeopleRoles",
+                column: "ShowID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Providers_Slug",
+                table: "Providers",
+                column: "Slug",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Seasons_ShowID_SeasonNumber",
+                table: "Seasons",
+                columns: new[] { "ShowID", "SeasonNumber" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Shows_Slug",
+                table: "Shows",
+                column: "Slug",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Shows_StudioID",
+                table: "Shows",
+                column: "StudioID");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Studios_Slug",
+                table: "Studios",
+                column: "Slug",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Tracks_EpisodeID",
+                table: "Tracks",
+                column: "EpisodeID");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Link<Collection, Show>");
+
+            migrationBuilder.DropTable(
+                name: "Link<Library, Collection>");
+
+            migrationBuilder.DropTable(
+                name: "Link<Library, ProviderID>");
+
+            migrationBuilder.DropTable(
+                name: "Link<Library, Show>");
+
+            migrationBuilder.DropTable(
+                name: "Link<Show, Genre>");
+
+            migrationBuilder.DropTable(
+                name: "MetadataIds");
+
+            migrationBuilder.DropTable(
+                name: "PeopleRoles");
+
+            migrationBuilder.DropTable(
+                name: "Tracks");
+
+            migrationBuilder.DropTable(
+                name: "Collections");
+
+            migrationBuilder.DropTable(
+                name: "Libraries");
+
+            migrationBuilder.DropTable(
+                name: "Genres");
+
+            migrationBuilder.DropTable(
+                name: "Providers");
+
+            migrationBuilder.DropTable(
+                name: "People");
+
+            migrationBuilder.DropTable(
+                name: "Episodes");
+
+            migrationBuilder.DropTable(
+                name: "Seasons");
+
+            migrationBuilder.DropTable(
+                name: "Shows");
+
+            migrationBuilder.DropTable(
+                name: "Studios");
+        }
+    }
+}

Kyoo/Models/DatabaseMigrations/Internal/DatabaseContextModelSnapshot.cs

@@ -0,0 +1,776 @@
+// <auto-generated />
+using System;
+using Kyoo;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace Kyoo.Models.DatabaseMigrations.Internal
+{
+    [DbContext(typeof(DatabaseContext))]
+    partial class DatabaseContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasPostgresEnum(null, "item_type", new[] { "show", "movie", "collection" })
+                .HasPostgresEnum(null, "status", new[] { "finished", "airing", "planned", "unknown" })
+                .HasPostgresEnum(null, "stream_type", new[] { "unknown", "video", "audio", "subtitle", "font" })
+                .HasAnnotation("Relational:MaxIdentifierLength", 63)
+                .HasAnnotation("ProductVersion", "5.0.3")
+                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            modelBuilder.Entity("Kyoo.Models.Collection", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Collections");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Episode", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("AbsoluteNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("EpisodeNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int>("Runtime")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SeasonID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SeasonNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShowID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Thumb")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("SeasonID");
+
+                    b.HasIndex("ShowID", "SeasonNumber", "EpisodeNumber", "AbsoluteNumber")
+                        .IsUnique();
+
+                    b.ToTable("Episodes");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Genre", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Genres");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Library", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string[]>("Paths")
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Libraries");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Collection, Kyoo.Models.Show>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Collection, Show>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.Collection>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Library, Collection>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.ProviderID>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Library, ProviderID>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.Show>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Library, Show>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Show, Kyoo.Models.Genre>", b =>
+                {
+                    b.Property<int>("FirstID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SecondID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("FirstID", "SecondID");
+
+                    b.HasIndex("SecondID");
+
+                    b.ToTable("Link<Show, Genre>");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.MetadataID", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("DataID")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EpisodeID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Link")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("PeopleID")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ProviderID")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SeasonID")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ShowID")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("EpisodeID");
+
+                    b.HasIndex("PeopleID");
+
+                    b.HasIndex("ProviderID");
+
+                    b.HasIndex("SeasonID");
+
+                    b.HasIndex("ShowID");
+
+                    b.ToTable("MetadataIds");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.People", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("People");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.PeopleRole", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("PeopleID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ShowID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("PeopleID");
+
+                    b.HasIndex("ShowID");
+
+                    b.ToTable("PeopleRoles");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.ProviderID", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Logo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Providers");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Season", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("text");
+
+                    b.Property<int>("SeasonNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("ShowID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("ShowID", "SeasonNumber")
+                        .IsUnique();
+
+                    b.ToTable("Seasons");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Show", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string[]>("Aliases")
+                        .HasColumnType("text[]");
+
+                    b.Property<string>("Backdrop")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("EndYear")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsMovie")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Logo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Poster")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("StartYear")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("StudioID")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TrailerUrl")
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.HasIndex("StudioID");
+
+                    b.ToTable("Shows");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Studio", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Slug")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("Slug")
+                        .IsUnique();
+
+                    b.ToTable("Studios");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Track", b =>
+                {
+                    b.Property<int>("ID")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("text");
+
+                    b.Property<int>("EpisodeID")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsExternal")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsForced")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ID");
+
+                    b.HasIndex("EpisodeID");
+
+                    b.ToTable("Tracks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Episode", b =>
+                {
+                    b.HasOne("Kyoo.Models.Season", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonID");
+
+                    b.HasOne("Kyoo.Models.Show", "Show")
+                        .WithMany("Episodes")
+                        .HasForeignKey("ShowID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Collection, Kyoo.Models.Show>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Collection", "First")
+                        .WithMany("ShowLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Show", "Second")
+                        .WithMany("CollectionLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.Collection>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Library", "First")
+                        .WithMany("CollectionLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Collection", "Second")
+                        .WithMany("LibraryLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.ProviderID>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Library", "First")
+                        .WithMany("ProviderLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.ProviderID", "Second")
+                        .WithMany("LibraryLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Library, Kyoo.Models.Show>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Library", "First")
+                        .WithMany("ShowLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Show", "Second")
+                        .WithMany("LibraryLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Link<Kyoo.Models.Show, Kyoo.Models.Genre>", b =>
+                {
+                    b.HasOne("Kyoo.Models.Show", "First")
+                        .WithMany("GenreLinks")
+                        .HasForeignKey("FirstID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Genre", "Second")
+                        .WithMany("ShowLinks")
+                        .HasForeignKey("SecondID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("First");
+
+                    b.Navigation("Second");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.MetadataID", b =>
+                {
+                    b.HasOne("Kyoo.Models.Episode", "Episode")
+                        .WithMany("ExternalIDs")
+                        .HasForeignKey("EpisodeID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Kyoo.Models.People", "People")
+                        .WithMany("ExternalIDs")
+                        .HasForeignKey("PeopleID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Kyoo.Models.ProviderID", "Provider")
+                        .WithMany("MetadataLinks")
+                        .HasForeignKey("ProviderID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Season", "Season")
+                        .WithMany("ExternalIDs")
+                        .HasForeignKey("SeasonID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Kyoo.Models.Show", "Show")
+                        .WithMany("ExternalIDs")
+                        .HasForeignKey("ShowID")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Episode");
+
+                    b.Navigation("People");
+
+                    b.Navigation("Provider");
+
+                    b.Navigation("Season");
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.PeopleRole", b =>
+                {
+                    b.HasOne("Kyoo.Models.People", "People")
+                        .WithMany("Roles")
+                        .HasForeignKey("PeopleID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Kyoo.Models.Show", "Show")
+                        .WithMany("People")
+                        .HasForeignKey("ShowID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("People");
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Season", b =>
+                {
+                    b.HasOne("Kyoo.Models.Show", "Show")
+                        .WithMany("Seasons")
+                        .HasForeignKey("ShowID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Show", b =>
+                {
+                    b.HasOne("Kyoo.Models.Studio", "Studio")
+                        .WithMany("Shows")
+                        .HasForeignKey("StudioID");
+
+                    b.Navigation("Studio");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Track", b =>
+                {
+                    b.HasOne("Kyoo.Models.Episode", "Episode")
+                        .WithMany("Tracks")
+                        .HasForeignKey("EpisodeID")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Episode");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Collection", b =>
+                {
+                    b.Navigation("LibraryLinks");
+
+                    b.Navigation("ShowLinks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Episode", b =>
+                {
+                    b.Navigation("ExternalIDs");
+
+                    b.Navigation("Tracks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Genre", b =>
+                {
+                    b.Navigation("ShowLinks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Library", b =>
+                {
+                    b.Navigation("CollectionLinks");
+
+                    b.Navigation("ProviderLinks");
+
+                    b.Navigation("ShowLinks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.People", b =>
+                {
+                    b.Navigation("ExternalIDs");
+
+                    b.Navigation("Roles");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.ProviderID", b =>
+                {
+                    b.Navigation("LibraryLinks");
+
+                    b.Navigation("MetadataLinks");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Season", b =>
+                {
+                    b.Navigation("Episodes");
+
+                    b.Navigation("ExternalIDs");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Show", b =>
+                {
+                    b.Navigation("CollectionLinks");
+
+                    b.Navigation("Episodes");
+
+                    b.Navigation("ExternalIDs");
+
+                    b.Navigation("GenreLinks");
+
+                    b.Navigation("LibraryLinks");
+
+                    b.Navigation("People");
+
+                    b.Navigation("Seasons");
+                });
+
+            modelBuilder.Entity("Kyoo.Models.Studio", b =>
+                {
+                    b.Navigation("Shows");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}