Emby improvments on the way we sync/cache the data.

src/Ombi.Core.Tests/Rule/Search/EmbyAvailabilityRuleTests.cs

@@ -25,7 +25,7 @@ namespace Ombi.Core.Tests.Rule.Search
         [Test]
         public async Task Movie_ShouldBe_Available_WhenFoundInEmby()
         {
-            ContextMock.Setup(x => x.Get(It.IsAny<string>())).ReturnsAsync(new EmbyContent
+            ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny<string>())).ReturnsAsync(new EmbyContent
             {
                 ProviderId = "123"
             });
@@ -39,7 +39,7 @@ namespace Ombi.Core.Tests.Rule.Search
         [Test]
         public async Task Movie_ShouldBe_NotAvailable_WhenNotFoundInEmby()
         {
-            ContextMock.Setup(x => x.Get(It.IsAny<string>())).Returns(Task.FromResult(default(EmbyContent)));
+            ContextMock.Setup(x => x.GetByTheMovieDbId(It.IsAny<string>())).Returns(Task.FromResult(default(EmbyContent)));
             var search = new SearchMovieViewModel();
             var result = await Rule.Execute(search);
 

src/Ombi.Core/Engine/RecentlyAddedEngine.cs

@@ -152,7 +152,9 @@ namespace Ombi.Core.Engine
                 model.Add(new RecentlyAddedMovieModel
                 {
                     Id = emby.Id,
-                    ImdbId = emby.ProviderId,
+                    ImdbId = emby.ImdbId,
+                    TheMovieDbId = emby.TheMovieDbId,
+                    TvDbId = emby.TvDbId,
                     AddedAt = emby.AddedAt,
                     Title = emby.Title,
                 });
@@ -211,7 +213,9 @@ namespace Ombi.Core.Engine
                     model.Add(new RecentlyAddedTvModel
                     {
                         Id = emby.Id,
-                        ImdbId = emby.ProviderId,
+                        ImdbId = emby.ImdbId,
+                        TvDbId = emby.TvDbId,
+                        TheMovieDbId = emby.TheMovieDbId,
                         AddedAt = emby.AddedAt,
                         Title = emby.Title,
                         EpisodeNumber = episode.EpisodeNumber,

src/Ombi.Core/Rule/Rules/Search/EmbyAvailabilityRule.cs

@@ -23,20 +23,20 @@ namespace Ombi.Core.Rule.Rules.Search
             EmbyContent item = null;
             if (obj.ImdbId.HasValue())
             {
-                item = await EmbyContentRepository.Get(obj.ImdbId);
+                item = await EmbyContentRepository.GetByImdbId(obj.ImdbId);
             }
             if (item == null)
             {
                 if (obj.TheMovieDbId.HasValue())
                 {
-                    item = await EmbyContentRepository.Get(obj.TheMovieDbId);
+                    item = await EmbyContentRepository.GetByTheMovieDbId(obj.TheMovieDbId);
                 }
 
                 if (item == null)
                 {
                     if (obj.TheTvDbId.HasValue())
                     {
-                        item = await EmbyContentRepository.Get(obj.TheTvDbId);
+                        item = await EmbyContentRepository.GetByTvDbId(obj.TheTvDbId);
                     }
                 }
             }

src/Ombi.Schedule/Jobs/Emby/EmbyAvaliabilityChecker.cs

@@ -70,7 +70,16 @@ namespace Ombi.Schedule.Jobs.Emby
 
             foreach (var movie in movies)
             {
-                var embyContent = await _repo.Get(movie.ImdbId);
+                EmbyContent embyContent = null;
+                if (movie.TheMovieDbId > 0)
+                {
+                    embyContent = await _repo.GetByTheMovieDbId(movie.TheMovieDbId.ToString());
+                }
+                else if(movie.ImdbId.HasValue())
+                {
+                    embyContent = await _repo.GetByImdbId(movie.ImdbId);
+                }
+                
                 if (embyContent == null)
                 {
                     // We don't have this yet
@@ -112,8 +121,20 @@ namespace Ombi.Schedule.Jobs.Emby
 
             foreach (var child in tv)
             {
-                var tvDbId = child.ParentRequest.TvDbId;
-                var seriesEpisodes = embyEpisodes.Where(x => x.Series.ProviderId == tvDbId.ToString());
+                IQueryable<EmbyEpisode> seriesEpisodes;
+                if (child.ParentRequest.TvDbId > 0)
+                {
+                    seriesEpisodes = embyEpisodes.Where(x => x.Series.TvDbId == child.ParentRequest.TvDbId.ToString());
+                }
+                else if(child.ParentRequest.ImdbId.HasValue())
+                {
+                    seriesEpisodes = embyEpisodes.Where(x => x.Series.ImdbId == child.ParentRequest.ImdbId);
+                }
+                else
+                {
+                    continue;
+                }
+
                 foreach (var season in child.SeasonRequests)
                 {
                     foreach (var episode in season.Episodes)

src/Ombi.Schedule/Jobs/Emby/EmbyContentSync.cs

@@ -38,12 +38,21 @@ namespace Ombi.Schedule.Jobs.Emby
 
         public async Task Start()
         {
-           var embySettings = await _settings.GetSettingsAsync();
+            var embySettings = await _settings.GetSettingsAsync();
             if (!embySettings.Enable)
                 return;
 
             foreach (var server in embySettings.Servers)
-                await StartServerCache(server);
+            {
+                try
+                {
+                    await StartServerCache(server);
+                }
+                catch (Exception e)
+                {
+                    _logger.LogError(e, "Exception when caching Emby for server {0}", server.Name);
+                }
+            }
 
             // Episodes
             BackgroundJob.Enqueue(() => _episodeSync.Start());
@@ -55,8 +64,11 @@ namespace Ombi.Schedule.Jobs.Emby
             if (!ValidateSettings(server))
                 return;
 
+            await _repo.ExecuteSql("DELETE FROM EmbyEpisode");
+            await _repo.ExecuteSql("DELETE FROM EmbyContent");
+
             var movies = await _api.GetAllMovies(server.ApiKey, server.AdministratorId, server.FullUri);
-            var mediaToAdd = new List<EmbyContent>();
+            var mediaToAdd = new HashSet<EmbyContent>();
             foreach (var movie in movies.Items)
             {
                 if (movie.Type.Equals("boxset", StringComparison.CurrentCultureIgnoreCase))
@@ -96,7 +108,9 @@ namespace Ombi.Schedule.Jobs.Emby
                 if (existingTv == null)
                     mediaToAdd.Add(new EmbyContent
                     {
-                        ProviderId = tvInfo.ProviderIds.Tvdb,
+                        TvDbId = tvInfo.ProviderIds?.Tvdb,
+                        ImdbId = tvInfo.ProviderIds?.Imdb,
+                        TheMovieDbId = tvInfo.ProviderIds?.Tmdb,
                         Title = tvInfo.Name,
                         Type = EmbyMediaType.Series,
                         EmbyId = tvShow.Id,
@@ -110,18 +124,14 @@ namespace Ombi.Schedule.Jobs.Emby
 
         private async Task ProcessMovies(MovieInformation movieInfo, ICollection<EmbyContent> content)
         {
-            if (string.IsNullOrEmpty(movieInfo.ProviderIds.Imdb))
-            {
-                Log.Error("Provider Id on movie {0} is null", movieInfo.Name);
-                return;
-            }
             // Check if it exists
             var existingMovie = await _repo.GetByEmbyId(movieInfo.Id);
 
             if (existingMovie == null)
                 content.Add(new EmbyContent
                 {
-                    ProviderId = movieInfo.ProviderIds.Imdb,
+                    ImdbId = movieInfo.ProviderIds.Imdb,
+                    TheMovieDbId = movieInfo.ProviderIds?.Tmdb,
                     Title = movieInfo.Name,
                     Type = EmbyMediaType.Movie,
                     EmbyId = movieInfo.Id,

src/Ombi.Schedule/Jobs/Emby/EmbyEpisodeSync.cs

@@ -85,10 +85,10 @@ namespace Ombi.Schedule.Jobs.Emby
                 }
 
                 var epInfo = await _api.GetEpisodeInformation(ep.Id, server.ApiKey, server.AdministratorId, server.FullUri);
-                if (epInfo?.ProviderIds?.Tvdb == null)
-                {
-                    continue;
-                }
+                //if (epInfo?.ProviderIds?.Tvdb == null)
+                //{
+                //    continue;
+                //}
 
                 // Let's make sure we have the parent request, stop those pesky forign key errors,
                 // Damn me having data integrity
@@ -109,7 +109,9 @@ namespace Ombi.Schedule.Jobs.Emby
                         EpisodeNumber = ep.IndexNumber,
                         SeasonNumber = ep.ParentIndexNumber,
                         ParentId = ep.SeriesId,
-                        ProviderId = epInfo.ProviderIds.Tvdb,
+                        TvDbId = epInfo.ProviderIds.Tvdb,
+                        TheMovieDbId = epInfo.ProviderIds.Tmdb,
+                        ImdbId = epInfo.ProviderIds.Imdb,
                         Title = ep.Name,
                         AddedAt = DateTime.UtcNow
                     });

src/Ombi.Schedule/Jobs/Ombi/NewsletterJob.cs

@@ -292,14 +292,21 @@ namespace Ombi.Schedule.Jobs.Ombi
             var ordered = embyContent.OrderByDescending(x => x.AddedAt);
             foreach (var content in ordered)
             {
-                var imdbId = content.ProviderId;
-                var findResult = await _movieApi.Find(imdbId, ExternalSource.imdb_id);
-                var result = findResult.movie_results?.FirstOrDefault();
-                if(result == null)
+                var theMovieDbId = content.TheMovieDbId;
+                if (!content.TheMovieDbId.HasValue())
                 {
-                    continue;
+                    var imdbId = content.ImdbId;
+                    var findResult = await _movieApi.Find(imdbId, ExternalSource.imdb_id);
+                    var result = findResult.movie_results?.FirstOrDefault();
+                    if (result == null)
+                    {
+                        continue;
+                    }
+
+                    theMovieDbId = result.id.ToString();
                 }
-                var info = await _movieApi.GetMovieInformationWithExtraInfo(result.id);
+          
+                var info = await _movieApi.GetMovieInformationWithExtraInfo(int.Parse(theMovieDbId));
                 if (info == null)
                 {
                     continue;
@@ -503,7 +510,11 @@ namespace Ombi.Schedule.Jobs.Ombi
             {
                 try
                 {
-                    int.TryParse(t.ProviderId, out var tvdbId);
+                    if (!t.TvDbId.HasValue())
+                    {
+                        continue;
+                    }
+                    int.TryParse(t.TvDbId, out var tvdbId);
                     var info = await _tvApi.ShowLookupByTheTvDbId(tvdbId);
                     if (info == null)
                     {

src/Ombi.Schedule/Jobs/Ombi/RefreshMetadata.cs

@@ -10,7 +10,6 @@ using Ombi.Core.Settings.Models.External;
 using Ombi.Helpers;
 using Ombi.Store.Entities;
 using Ombi.Store.Repository;
-using Ombi.Store.Repository.Requests;
 
 namespace Ombi.Schedule.Jobs.Ombi
 {
@@ -44,6 +43,7 @@ namespace Ombi.Schedule.Jobs.Ombi
                 if (settings.Enable)
                 {
                     await StartPlex();
+                    await StartEmby();
                 }
             }
             catch (Exception e)
@@ -61,6 +61,12 @@ namespace Ombi.Schedule.Jobs.Ombi
             await StartPlexTv();
         }
 
+        private async Task StartEmby()
+        {
+            await StartEmbyMovies();
+            await StartEmbyTv();
+        }
+
         private async Task StartPlexTv()
         {
             var allTv = _plexRepo.GetAll().Where(x =>
@@ -101,6 +107,46 @@ namespace Ombi.Schedule.Jobs.Ombi
             await _plexRepo.SaveChangesAsync();
         }
 
+        private async Task StartEmbyTv()
+        {
+            var allTv = _embyRepo.GetAll().Where(x =>
+                x.Type == EmbyMediaType.Series && (!x.TheMovieDbId.HasValue() || !x.ImdbId.HasValue() || !x.TvDbId.HasValue()));
+            var tvCount = 0;
+            foreach (var show in allTv)
+            {
+                var hasImdb = show.ImdbId.HasValue();
+                var hasTheMovieDb = show.TheMovieDbId.HasValue();
+                var hasTvDbId = show.TvDbId.HasValue();
+
+                if (!hasTheMovieDb)
+                {
+                    var id = await GetTheMovieDbId(hasTvDbId, hasImdb, show.TvDbId, show.ImdbId, show.Title);
+                    show.TheMovieDbId = id;
+                }
+
+                if (!hasImdb)
+                {
+                    var id = await GetImdbId(hasTheMovieDb, hasTvDbId, show.Title, show.TheMovieDbId, show.TvDbId);
+                    show.ImdbId = id;
+                    _embyRepo.UpdateWithoutSave(show);
+                }
+
+                if (!hasTvDbId)
+                {
+                    var id = await GetTvDbId(hasTheMovieDb, hasImdb, show.TheMovieDbId, show.ImdbId, show.Title);
+                    show.TvDbId = id;
+                    _embyRepo.UpdateWithoutSave(show);
+                }
+                tvCount++;
+                if (tvCount >= 20)
+                {
+                    await _embyRepo.SaveChangesAsync();
+                    tvCount = 0;
+                }
+            }
+            await _embyRepo.SaveChangesAsync();
+        }
+
         private async Task StartPlexMovies()
         {
             var allMovies = _plexRepo.GetAll().Where(x =>
@@ -135,7 +181,41 @@ namespace Ombi.Schedule.Jobs.Ombi
             await _plexRepo.SaveChangesAsync();
         }
 
-       private async Task<string> GetTheMovieDbId(bool hasTvDbId, bool hasImdb, string tvdbID, string imdbId, string title)
+        private async Task StartEmbyMovies()
+        {
+            var allMovies = _embyRepo.GetAll().Where(x =>
+                x.Type == EmbyMediaType.Movie && (!x.TheMovieDbId.HasValue() || !x.ImdbId.HasValue()));
+            int movieCount = 0;
+            foreach (var movie in allMovies)
+            {
+                var hasImdb = movie.ImdbId.HasValue();
+                var hasTheMovieDb = movie.TheMovieDbId.HasValue();
+                // Movies don't really use TheTvDb
+
+                if (!hasImdb)
+                {
+                    var imdbId = await GetImdbId(hasTheMovieDb, false, movie.Title, movie.TheMovieDbId, string.Empty);
+                    movie.ImdbId = imdbId;
+                    _embyRepo.UpdateWithoutSave(movie);
+                }
+                if (!hasTheMovieDb)
+                {
+                    var id = await GetTheMovieDbId(false, hasImdb, string.Empty, movie.ImdbId, movie.Title);
+                    movie.TheMovieDbId = id;
+                    _embyRepo.UpdateWithoutSave(movie);
+                }
+                movieCount++;
+                if (movieCount >= 20)
+                {
+                    await _embyRepo.SaveChangesAsync();
+                    movieCount = 0;
+                }
+            }
+
+            await _embyRepo.SaveChangesAsync();
+        }
+
+        private async Task<string> GetTheMovieDbId(bool hasTvDbId, bool hasImdb, string tvdbID, string imdbId, string title)
         {
             _log.LogInformation("The Media item {0} does not have a TheMovieDbId, searching for TheMovieDbId", title);
             FindResult result = null;

src/Ombi.Store/Entities/EmbyContent.cs

@@ -36,11 +36,18 @@ namespace Ombi.Store.Entities
     {
         public string Title { get; set; }
 
+        /// <summary>
+        /// OBSOLETE, Cannot delete due to DB migration issues with SQLite
+        /// </summary>
         public string ProviderId { get; set; }
         public string EmbyId { get; set; }
         public EmbyMediaType Type { get; set; }
         public DateTime AddedAt { get; set; }
 
+        public string ImdbId { get; set; }
+        public string TheMovieDbId { get; set; }
+        public string TvDbId { get; set; }
+
 
         public ICollection<EmbyEpisode> Episodes { get; set; }
     }

src/Ombi.Store/Entities/EmbyEpisode.cs

@@ -39,8 +39,14 @@ namespace Ombi.Store.Entities
         public int EpisodeNumber { get; set; }
         public int SeasonNumber { get; set; }
         public string ParentId { get; set; }
+        /// <summary>
+        /// NOT USED
+        /// </summary>
         public string ProviderId { get; set; }
         public DateTime AddedAt { get; set; }
+        public string TvDbId { get; set; }
+        public string ImdbId { get; set; }
+        public string TheMovieDbId { get; set; }
 
         public EmbyContent Series { get; set; }
     }

src/Ombi.Store/Migrations/20180406224743_EmbyMetadata.Designer.cs

@@ -0,0 +1,948 @@
+// <auto-generated />
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage;
+using Microsoft.EntityFrameworkCore.Storage.Internal;
+using Ombi.Helpers;
+using Ombi.Store.Context;
+using Ombi.Store.Entities;
+using Ombi.Store.Entities.Requests;
+using System;
+
+namespace Ombi.Store.Migrations
+{
+    [DbContext(typeof(OmbiContext))]
+    [Migration("20180406224743_EmbyMetadata")]
+    partial class EmbyMetadata
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.0.2-rtm-10011");
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ClaimType");
+
+                    b.Property<string>("ClaimValue");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("ProviderKey");
+
+                    b.Property<string>("ProviderDisplayName");
+
+                    b.Property<string>("UserId")
+                        .IsRequired();
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("RoleId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId");
+
+                    b.Property<string>("LoginProvider");
+
+                    b.Property<string>("Name");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.ApplicationConfiguration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Type");
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApplicationConfiguration");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Audit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AuditArea");
+
+                    b.Property<int>("AuditType");
+
+                    b.Property<DateTime>("DateTime");
+
+                    b.Property<string>("Description");
+
+                    b.Property<string>("User");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Audit");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.CouchPotatoCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("TheMovieDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CouchPotatoCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.EmbyContent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<string>("EmbyId")
+                        .IsRequired();
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<string>("ProviderId");
+
+                    b.Property<string>("TheMovieDbId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TvDbId");
+
+                    b.Property<int>("Type");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmbyContent");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.EmbyEpisode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<string>("EmbyId");
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<string>("ParentId");
+
+                    b.Property<string>("ProviderId");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<string>("TheMovieDbId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("EmbyEpisode");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.GlobalSettings", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Content");
+
+                    b.Property<string>("SettingsName");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("GlobalSettings");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.NotificationTemplates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("Agent");
+
+                    b.Property<bool>("Enabled");
+
+                    b.Property<string>("Message");
+
+                    b.Property<int>("NotificationType");
+
+                    b.Property<string>("Subject");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("NotificationTemplates");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.NotificationUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<string>("PlayerId");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("NotificationUserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.OmbiUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("AccessFailedCount");
+
+                    b.Property<string>("Alias");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken();
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(256);
+
+                    b.Property<bool>("EmailConfirmed");
+
+                    b.Property<string>("EmbyConnectUserId");
+
+                    b.Property<int?>("EpisodeRequestLimit");
+
+                    b.Property<DateTime?>("LastLoggedIn");
+
+                    b.Property<bool>("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd");
+
+                    b.Property<int?>("MovieRequestLimit");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256);
+
+                    b.Property<string>("PasswordHash");
+
+                    b.Property<string>("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed");
+
+                    b.Property<string>("ProviderUserId");
+
+                    b.Property<string>("SecurityStamp");
+
+                    b.Property<bool>("TwoFactorEnabled");
+
+                    b.Property<string>("UserAccessToken");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256);
+
+                    b.Property<int>("UserType");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasName("UserNameIndex");
+
+                    b.ToTable("AspNetUsers");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexEpisode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<int>("GrandparentKey");
+
+                    b.Property<int>("Key");
+
+                    b.Property<int>("ParentKey");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<string>("Title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GrandparentKey");
+
+                    b.ToTable("PlexEpisode");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexSeasonsContent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ParentKey");
+
+                    b.Property<int>("PlexContentId");
+
+                    b.Property<int?>("PlexServerContentId");
+
+                    b.Property<int>("SeasonKey");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexServerContentId");
+
+                    b.ToTable("PlexSeasonsContent");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexServerContent", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<int>("Key");
+
+                    b.Property<string>("Quality");
+
+                    b.Property<string>("ReleaseYear");
+
+                    b.Property<string>("TheMovieDbId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("TvDbId");
+
+                    b.Property<int>("Type");
+
+                    b.Property<string>("Url");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PlexServerContent");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.RadarrCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("HasFile");
+
+                    b.Property<int>("TheMovieDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RadarrCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.RecentlyAddedLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AddedAt");
+
+                    b.Property<int>("ContentId");
+
+                    b.Property<int>("ContentType");
+
+                    b.Property<int>("Type");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RecentlyAddedLog");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.ChildRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Approved");
+
+                    b.Property<bool>("Available");
+
+                    b.Property<bool?>("Denied");
+
+                    b.Property<string>("DeniedReason");
+
+                    b.Property<int?>("IssueId");
+
+                    b.Property<int>("ParentRequestId");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<DateTime>("RequestedDate");
+
+                    b.Property<string>("RequestedUserId");
+
+                    b.Property<int>("SeriesType");
+
+                    b.Property<string>("Title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentRequestId");
+
+                    b.HasIndex("RequestedUserId");
+
+                    b.ToTable("ChildRequests");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.IssueCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Value");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("IssueCategory");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.IssueComments", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Comment");
+
+                    b.Property<DateTime>("Date");
+
+                    b.Property<int?>("IssuesId");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssuesId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("IssueComments");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.Issues", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Description");
+
+                    b.Property<int>("IssueCategoryId");
+
+                    b.Property<int?>("IssueId");
+
+                    b.Property<string>("ProviderId");
+
+                    b.Property<int?>("RequestId");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<DateTime?>("ResovledDate");
+
+                    b.Property<int>("Status");
+
+                    b.Property<string>("Subject");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("UserReportedId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IssueCategoryId");
+
+                    b.HasIndex("IssueId");
+
+                    b.HasIndex("UserReportedId");
+
+                    b.ToTable("Issues");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Approved");
+
+                    b.Property<bool>("Available");
+
+                    b.Property<string>("Background");
+
+                    b.Property<bool?>("Denied");
+
+                    b.Property<string>("DeniedReason");
+
+                    b.Property<DateTime?>("DigitalReleaseDate");
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<int?>("IssueId");
+
+                    b.Property<string>("Overview");
+
+                    b.Property<string>("PosterPath");
+
+                    b.Property<int>("QualityOverride");
+
+                    b.Property<DateTime>("ReleaseDate");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<DateTime>("RequestedDate");
+
+                    b.Property<string>("RequestedUserId");
+
+                    b.Property<int>("RootPathOverride");
+
+                    b.Property<string>("Status");
+
+                    b.Property<int>("TheMovieDbId");
+
+                    b.Property<string>("Title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestedUserId");
+
+                    b.ToTable("MovieRequests");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.RequestLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("EpisodeCount");
+
+                    b.Property<DateTime>("RequestDate");
+
+                    b.Property<int>("RequestId");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RequestLog");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.TvRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("ImdbId");
+
+                    b.Property<string>("Overview");
+
+                    b.Property<string>("PosterPath");
+
+                    b.Property<int?>("QualityOverride");
+
+                    b.Property<DateTime>("ReleaseDate");
+
+                    b.Property<int?>("RootFolder");
+
+                    b.Property<string>("Status");
+
+                    b.Property<string>("Title");
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TvRequests");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.SickRageCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SickRageCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.SickRageEpisodeCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SickRageEpisodeCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.SonarrCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SonarrCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.SonarrEpisodeCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<bool>("HasFile");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.Property<int>("TvDbId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SonarrEpisodeCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Tokens", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("Token");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Tokens");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Repository.Requests.EpisodeRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<DateTime>("AirDate");
+
+                    b.Property<bool>("Approved");
+
+                    b.Property<bool>("Available");
+
+                    b.Property<int>("EpisodeNumber");
+
+                    b.Property<bool>("Requested");
+
+                    b.Property<int>("SeasonId");
+
+                    b.Property<string>("Title");
+
+                    b.Property<string>("Url");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("EpisodeRequests");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Repository.Requests.SeasonRequests", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ChildRequestId");
+
+                    b.Property<int>("SeasonNumber");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChildRequestId");
+
+                    b.ToTable("SeasonRequests");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ombi.Store.Entities.OmbiUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.EmbyEpisode", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.EmbyContent", "Series")
+                        .WithMany("Episodes")
+                        .HasForeignKey("ParentId")
+                        .HasPrincipalKey("EmbyId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.NotificationUserId", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany("NotificationUserIds")
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexEpisode", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.PlexServerContent", "Series")
+                        .WithMany("Episodes")
+                        .HasForeignKey("GrandparentKey")
+                        .HasPrincipalKey("Key")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.PlexSeasonsContent", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.PlexServerContent")
+                        .WithMany("Seasons")
+                        .HasForeignKey("PlexServerContentId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.ChildRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.Requests.TvRequests", "ParentRequest")
+                        .WithMany("ChildRequests")
+                        .HasForeignKey("ParentRequestId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "RequestedUser")
+                        .WithMany()
+                        .HasForeignKey("RequestedUserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.IssueComments", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.Requests.Issues", "Issues")
+                        .WithMany("Comments")
+                        .HasForeignKey("IssuesId");
+
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.Issues", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.Requests.IssueCategory", "IssueCategory")
+                        .WithMany()
+                        .HasForeignKey("IssueCategoryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("Ombi.Store.Entities.Requests.ChildRequests")
+                        .WithMany("Issues")
+                        .HasForeignKey("IssueId");
+
+                    b.HasOne("Ombi.Store.Entities.Requests.MovieRequests")
+                        .WithMany("Issues")
+                        .HasForeignKey("IssueId");
+
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "UserReported")
+                        .WithMany()
+                        .HasForeignKey("UserReportedId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.MovieRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "RequestedUser")
+                        .WithMany()
+                        .HasForeignKey("RequestedUserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.RequestLog", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Tokens", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Repository.Requests.EpisodeRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Repository.Requests.SeasonRequests", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Ombi.Store.Repository.Requests.SeasonRequests", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.Requests.ChildRequests", "ChildRequest")
+                        .WithMany("SeasonRequests")
+                        .HasForeignKey("ChildRequestId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Ombi.Store/Migrations/20180406224743_EmbyMetadata.cs

@@ -0,0 +1,69 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+
+namespace Ombi.Store.Migrations
+{
+    public partial class EmbyMetadata : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "ImdbId",
+                table: "EmbyEpisode",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "TheMovieDbId",
+                table: "EmbyEpisode",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "TvDbId",
+                table: "EmbyEpisode",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "ImdbId",
+                table: "EmbyContent",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "TheMovieDbId",
+                table: "EmbyContent",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "TvDbId",
+                table: "EmbyContent",
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ImdbId",
+                table: "EmbyEpisode");
+
+            migrationBuilder.DropColumn(
+                name: "TheMovieDbId",
+                table: "EmbyEpisode");
+
+            migrationBuilder.DropColumn(
+                name: "TvDbId",
+                table: "EmbyEpisode");
+
+            migrationBuilder.DropColumn(
+                name: "ImdbId",
+                table: "EmbyContent");
+
+            migrationBuilder.DropColumn(
+                name: "TheMovieDbId",
+                table: "EmbyContent");
+
+            migrationBuilder.DropColumn(
+                name: "TvDbId",
+                table: "EmbyContent");
+        }
+    }
+}

src/Ombi.Store/Migrations/OmbiContextModelSnapshot.cs

@@ -185,10 +185,16 @@ namespace Ombi.Store.Migrations
                     b.Property<string>("EmbyId")
                         .IsRequired();
 
+                    b.Property<string>("ImdbId");
+
                     b.Property<string>("ProviderId");
 
+                    b.Property<string>("TheMovieDbId");
+
                     b.Property<string>("Title");
 
+                    b.Property<string>("TvDbId");
+
                     b.Property<int>("Type");
 
                     b.HasKey("Id");
@@ -207,14 +213,20 @@ namespace Ombi.Store.Migrations
 
                     b.Property<int>("EpisodeNumber");
 
+                    b.Property<string>("ImdbId");
+
                     b.Property<string>("ParentId");
 
                     b.Property<string>("ProviderId");
 
                     b.Property<int>("SeasonNumber");
 
+                    b.Property<string>("TheMovieDbId");
+
                     b.Property<string>("Title");
 
+                    b.Property<string>("TvDbId");
+
                     b.HasKey("Id");
 
                     b.HasIndex("ParentId");

src/Ombi.Store/Repository/EmbyContentRepository.cs

@@ -35,42 +35,28 @@ using Ombi.Store.Entities;
 
 namespace Ombi.Store.Repository
 {
-    public class EmbyContentRepository : IEmbyContentRepository
+    public class EmbyContentRepository : Repository<EmbyContent>, IEmbyContentRepository
     {
 
-        public EmbyContentRepository(IOmbiContext db)
+        public EmbyContentRepository(IOmbiContext db):base(db)
         {
             Db = db;
         }
 
         private IOmbiContext Db { get; }
 
-        public IQueryable<EmbyContent> GetAll()
+        
+        public async Task<EmbyContent> GetByImdbId(string imdbid)
         {
-            return Db.EmbyContent.AsQueryable();
+            return await Db.EmbyContent.FirstOrDefaultAsync(x => x.ImdbId == imdbid);
         }
-
-        public async Task AddRange(IEnumerable<EmbyContent> content)
+        public async Task<EmbyContent> GetByTvDbId(string tv)
         {
-            Db.EmbyContent.AddRange(content);
-            await Db.SaveChangesAsync();
+            return await Db.EmbyContent.FirstOrDefaultAsync(x => x.TvDbId == tv);
         }
-
-        public async Task<bool> ContentExists(string providerId)
+        public async Task<EmbyContent> GetByTheMovieDbId(string mov)
         {
-            return await Db.EmbyContent.AnyAsync(x => x.ProviderId == providerId);
-        }
-
-        public async Task<EmbyContent> Add(EmbyContent content)
-        {
-            await Db.EmbyContent.AddAsync(content);
-            await Db.SaveChangesAsync();
-            return content;
-        }
-
-        public async Task<EmbyContent> Get(string providerId)
-        {
-            return await Db.EmbyContent.FirstOrDefaultAsync(x => x.ProviderId == providerId);
+            return await Db.EmbyContent.FirstOrDefaultAsync(x => x.TheMovieDbId == mov);
         }
 
         public IQueryable<EmbyContent> Get()
@@ -111,23 +97,9 @@ namespace Ombi.Store.Repository
             await Db.SaveChangesAsync();
         }
 
-        private bool _disposed;
-        protected virtual void Dispose(bool disposing)
-        {
-            if (_disposed)
-                return;
-
-            if (disposing)
-            {
-                Db?.Dispose();
-            }
-            _disposed = true;
-        }
-
-        public void Dispose()
+        public void UpdateWithoutSave(EmbyContent existingContent)
         {
-            Dispose(true);
-            GC.SuppressFinalize(this);
+            Db.EmbyContent.Update(existingContent);
         }
     }
 }

src/Ombi.Store/Repository/IEmbyContentRepository.cs

@@ -6,19 +6,19 @@ using Ombi.Store.Entities;
 
 namespace Ombi.Store.Repository
 {
-    public interface IEmbyContentRepository : IDisposable
+    public interface IEmbyContentRepository : IRepository<EmbyContent>
     {
-        Task<EmbyContent> Add(EmbyContent content);
-        Task AddRange(IEnumerable<EmbyContent> content);
-        Task<bool> ContentExists(string providerId);
         IQueryable<EmbyContent> Get();
-        Task<EmbyContent> Get(string providerId);
-        IQueryable<EmbyContent> GetAll();
+        Task<EmbyContent> GetByTheMovieDbId(string mov);
+        Task<EmbyContent> GetByTvDbId(string tv);
+        Task<EmbyContent> GetByImdbId(string imdbid);
         Task<EmbyContent> GetByEmbyId(string embyId);
         Task Update(EmbyContent existingContent);
         IQueryable<EmbyEpisode> GetAllEpisodes();
         Task<EmbyEpisode> Add(EmbyEpisode content);
         Task<EmbyEpisode> GetEpisodeByEmbyId(string key);
         Task AddRange(IEnumerable<EmbyEpisode> content);
+
+        void UpdateWithoutSave(EmbyContent existingContent);
     }
 }