From 207c60b7f814a505918575adc78132758b617439 Mon Sep 17 00:00:00 2001
From: Jamie <tidusjar@gmail.com>
Date: Fri, 24 Aug 2018 21:25:46 +0100
Subject: [PATCH] Added the lidarr sync !wip

---
 src/Ombi.Api.Lidarr/ILidarrApi.cs             |    2 +
 src/Ombi.Api.Lidarr/LidarrApi.cs              |   17 +-
 src/Ombi.DependencyInjection/IocExtensions.cs |    4 +
 src/Ombi.Helpers/LoggingEvents.cs             |    1 +
 src/Ombi.Schedule/JobSetup.cs                 |    6 +-
 .../Jobs/Lidarr/ILidarrAlbumSync.cs           |   13 +
 .../Jobs/Lidarr/ILidarrArtistSync.cs          |   13 +
 .../Jobs/Lidarr/LidarrAlbumSync.cs            |  109 ++
 .../Jobs/Lidarr/LidarrArtistSync.cs           |  115 ++
 src/Ombi.Schedule/Ombi.Schedule.csproj        |    1 +
 .../Settings/Models/JobSettings.cs            |    1 +
 .../Settings/Models/JobSettingsHelper.cs      |    4 +
 src/Ombi.Store/Context/IOmbiContext.cs        |    2 +
 src/Ombi.Store/Context/OmbiContext.cs         |    2 +
 src/Ombi.Store/Entities/LidarrAlbumCache.cs   |   19 +
 src/Ombi.Store/Entities/LidarrArtistCache.cs  |   17 +
 .../20180824202308_LidarrSyncJobs.Designer.cs | 1095 +++++++++++++++++
 .../20180824202308_LidarrSyncJobs.cs          |   65 +
 .../Migrations/OmbiContextModelSnapshot.cs    |   50 +
 .../ClientApp/app/interfaces/ISettings.ts     |    1 +
 .../search/music/albumsearch.component.html   |    6 +-
 .../app/settings/jobs/jobs.component.html     |   17 +-
 src/Ombi/Controllers/SettingsController.cs    |    1 +
 23 files changed, 1551 insertions(+), 10 deletions(-)
 create mode 100644 src/Ombi.Schedule/Jobs/Lidarr/ILidarrAlbumSync.cs
 create mode 100644 src/Ombi.Schedule/Jobs/Lidarr/ILidarrArtistSync.cs
 create mode 100644 src/Ombi.Schedule/Jobs/Lidarr/LidarrAlbumSync.cs
 create mode 100644 src/Ombi.Schedule/Jobs/Lidarr/LidarrArtistSync.cs
 create mode 100644 src/Ombi.Store/Entities/LidarrAlbumCache.cs
 create mode 100644 src/Ombi.Store/Entities/LidarrArtistCache.cs
 create mode 100644 src/Ombi.Store/Migrations/20180824202308_LidarrSyncJobs.Designer.cs
 create mode 100644 src/Ombi.Store/Migrations/20180824202308_LidarrSyncJobs.cs

diff --git a/src/Ombi.Api.Lidarr/ILidarrApi.cs b/src/Ombi.Api.Lidarr/ILidarrApi.cs
index 9b2460db9..2fe74f803 100644
--- a/src/Ombi.Api.Lidarr/ILidarrApi.cs
+++ b/src/Ombi.Api.Lidarr/ILidarrApi.cs
@@ -14,5 +14,7 @@ namespace Ombi.Api.Lidarr
         Task<ArtistResult> GetArtistByForeignId(string foreignArtistId, string apiKey, string baseUrl);
         Task<AlbumByArtistResponse> GetAlbumsByArtist(int artistId, string apiKey, string baseUrl);
         Task<AlbumLookup> GetAlbumByForeignId(string foreignArtistId, string apiKey, string baseUrl);
+        Task<List<ArtistResult>> GetArtists(string apiKey, string baseUrl);
+        Task<List<AlbumByArtistResponse>> GetAllAlbums(string apiKey, string baseUrl);
     }
 }
\ No newline at end of file
diff --git a/src/Ombi.Api.Lidarr/LidarrApi.cs b/src/Ombi.Api.Lidarr/LidarrApi.cs
index 52bacd105..09b670afa 100644
--- a/src/Ombi.Api.Lidarr/LidarrApi.cs
+++ b/src/Ombi.Api.Lidarr/LidarrApi.cs
@@ -72,7 +72,6 @@ namespace Ombi.Api.Lidarr
             return Api.Request<ArtistResult>(request);
         }
 
-
         public async Task<AlbumLookup> GetAlbumByForeignId(string foreignArtistId, string apiKey, string baseUrl)
         {
             var request = new Request($"{ApiVersion}/album/lookup", baseUrl, HttpMethod.Get);
@@ -92,6 +91,22 @@ namespace Ombi.Api.Lidarr
             return Api.Request<AlbumByArtistResponse>(request);
         }
 
+        public Task<List<ArtistResult>> GetArtists(string apiKey, string baseUrl)
+        {
+            var request = new Request($"{ApiVersion}/artist", baseUrl, HttpMethod.Get);
+
+            AddHeaders(request, apiKey);
+            return Api.Request<List<ArtistResult>>(request);
+        }
+
+        public Task<List<AlbumByArtistResponse>> GetAllAlbums(string apiKey, string baseUrl)
+        {
+            var request = new Request($"{ApiVersion}/album", baseUrl, HttpMethod.Get);
+
+            AddHeaders(request, apiKey);
+            return Api.Request<List<AlbumByArtistResponse>>(request);
+        }
+
         private void AddHeaders(Request request, string key)
         {
             request.AddHeader("X-Api-Key", key);
diff --git a/src/Ombi.DependencyInjection/IocExtensions.cs b/src/Ombi.DependencyInjection/IocExtensions.cs
index 92a86c5f6..52f3db919 100644
--- a/src/Ombi.DependencyInjection/IocExtensions.cs
+++ b/src/Ombi.DependencyInjection/IocExtensions.cs
@@ -54,9 +54,11 @@ using PlexContentCacher = Ombi.Schedule.Jobs.Plex;
 using Ombi.Api.Telegram;
 using Ombi.Core.Authentication;
 using Ombi.Core.Processor;
+using Ombi.Schedule.Jobs.Lidarr;
 using Ombi.Schedule.Jobs.Plex.Interfaces;
 using Ombi.Schedule.Jobs.SickRage;
 using Ombi.Schedule.Processor;
+using Ombi.Store.Entities;
 
 namespace Ombi.DependencyInjection
 {
@@ -185,6 +187,8 @@ namespace Ombi.DependencyInjection
             services.AddTransient<IRefreshMetadata, RefreshMetadata>();
             services.AddTransient<INewsletterJob, NewsletterJob>();
             services.AddTransient<IPlexRecentlyAddedSync, PlexRecentlyAddedSync>();
+            services.AddTransient<ILidarrAlbumSync, LidarrAlbumSync>();
+            services.AddTransient<ILidarrArtistSync, LidarrArtistSync>();
         }
     }
 }
diff --git a/src/Ombi.Helpers/LoggingEvents.cs b/src/Ombi.Helpers/LoggingEvents.cs
index 39c309102..40ec3fd2b 100644
--- a/src/Ombi.Helpers/LoggingEvents.cs
+++ b/src/Ombi.Helpers/LoggingEvents.cs
@@ -20,6 +20,7 @@ namespace Ombi.Helpers
         public static EventId CouchPotatoCacher => new EventId(2007);
         public static EventId PlexContentCacher => new EventId(2008);
         public static EventId SickRageCacher => new EventId(2009);
+        public static EventId LidarrArtistCache => new EventId(2010);
         
         public static EventId MovieSender => new EventId(3000);
 
diff --git a/src/Ombi.Schedule/JobSetup.cs b/src/Ombi.Schedule/JobSetup.cs
index e24e4bd87..f82c96fba 100644
--- a/src/Ombi.Schedule/JobSetup.cs
+++ b/src/Ombi.Schedule/JobSetup.cs
@@ -4,6 +4,7 @@ using Ombi.Core.Settings;
 using Ombi.Schedule.Jobs;
 using Ombi.Schedule.Jobs.Couchpotato;
 using Ombi.Schedule.Jobs.Emby;
+using Ombi.Schedule.Jobs.Lidarr;
 using Ombi.Schedule.Jobs.Ombi;
 using Ombi.Schedule.Jobs.Plex;
 using Ombi.Schedule.Jobs.Radarr;
@@ -19,7 +20,7 @@ namespace Ombi.Schedule
             IOmbiAutomaticUpdater updater, IEmbyContentSync embySync, IPlexUserImporter userImporter,
             IEmbyUserImporter embyUserImporter, ISonarrSync cache, ICouchPotatoSync cpCache,
             ISettingsService<JobSettings> jobsettings, ISickRageSync srSync, IRefreshMetadata refresh,
-            INewsletterJob newsletter, IPlexRecentlyAddedSync recentlyAddedPlex)
+            INewsletterJob newsletter, IPlexRecentlyAddedSync recentlyAddedPlex, ILidarrArtistSync artist)
         {
             _plexContentSync = plexContentSync;
             _radarrSync = radarrSync;
@@ -34,6 +35,7 @@ namespace Ombi.Schedule
             _refreshMetadata = refresh;
             _newsletter = newsletter;
             _plexRecentlyAddedSync = recentlyAddedPlex;
+            _lidarrArtistSync = artist;
         }
 
         private readonly IPlexContentSync _plexContentSync;
@@ -49,6 +51,7 @@ namespace Ombi.Schedule
         private readonly ISettingsService<JobSettings> _jobSettings;
         private readonly IRefreshMetadata _refreshMetadata;
         private readonly INewsletterJob _newsletter;
+        private readonly ILidarrArtistSync _lidarrArtistSync;
 
         public void Setup()
         {
@@ -62,6 +65,7 @@ namespace Ombi.Schedule
             RecurringJob.AddOrUpdate(() => _cpCache.Start(), JobSettingsHelper.CouchPotato(s));
             RecurringJob.AddOrUpdate(() => _srSync.Start(), JobSettingsHelper.SickRageSync(s));
             RecurringJob.AddOrUpdate(() => _refreshMetadata.Start(), JobSettingsHelper.RefreshMetadata(s));
+            RecurringJob.AddOrUpdate(() => _lidarrArtistSync.CacheContent(), JobSettingsHelper.LidarrArtistSync(s));
 
             RecurringJob.AddOrUpdate(() => _updater.Update(null), JobSettingsHelper.Updater(s));
 
diff --git a/src/Ombi.Schedule/Jobs/Lidarr/ILidarrAlbumSync.cs b/src/Ombi.Schedule/Jobs/Lidarr/ILidarrAlbumSync.cs
new file mode 100644
index 000000000..56444b105
--- /dev/null
+++ b/src/Ombi.Schedule/Jobs/Lidarr/ILidarrAlbumSync.cs
@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Ombi.Store.Entities;
+
+namespace Ombi.Schedule.Jobs.Lidarr
+{
+    public interface ILidarrAlbumSync
+    {
+        Task CacheContent();
+        void Dispose();
+        Task<IEnumerable<LidarrAlbumCache>> GetCachedContent();
+    }
+}
\ No newline at end of file
diff --git a/src/Ombi.Schedule/Jobs/Lidarr/ILidarrArtistSync.cs b/src/Ombi.Schedule/Jobs/Lidarr/ILidarrArtistSync.cs
new file mode 100644
index 000000000..1d3424756
--- /dev/null
+++ b/src/Ombi.Schedule/Jobs/Lidarr/ILidarrArtistSync.cs
@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Ombi.Store.Entities;
+
+namespace Ombi.Schedule.Jobs.Lidarr
+{
+    public interface ILidarrArtistSync
+    {
+        Task CacheContent();
+        void Dispose();
+        Task<IEnumerable<LidarrArtistCache>> GetCachedContent();
+    }
+}
\ No newline at end of file
diff --git a/src/Ombi.Schedule/Jobs/Lidarr/LidarrAlbumSync.cs b/src/Ombi.Schedule/Jobs/Lidarr/LidarrAlbumSync.cs
new file mode 100644
index 000000000..031a9e9f5
--- /dev/null
+++ b/src/Ombi.Schedule/Jobs/Lidarr/LidarrAlbumSync.cs
@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.Extensions.Logging;
+using Ombi.Api.Lidarr;
+using Ombi.Api.Radarr;
+using Ombi.Core.Settings;
+using Ombi.Helpers;
+using Ombi.Settings.Settings.Models.External;
+using Ombi.Store.Context;
+using Ombi.Store.Entities;
+using Serilog;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace Ombi.Schedule.Jobs.Lidarr
+{
+    public class LidarrAlbumSync : ILidarrAlbumSync
+    {
+        public LidarrAlbumSync(ISettingsService<LidarrSettings> lidarr, ILidarrApi lidarrApi, ILogger<LidarrAlbumSync> log, IOmbiContext ctx)
+        {
+            _lidarrSettings = lidarr;
+            _lidarrApi = lidarrApi;
+            _logger = log;
+            _ctx = ctx;
+            _lidarrSettings.ClearCache();
+        }
+
+        private readonly ISettingsService<LidarrSettings> _lidarrSettings;
+        private readonly ILidarrApi _lidarrApi;
+        private readonly ILogger _logger;
+        private readonly IOmbiContext _ctx;
+        
+        public async Task CacheContent()
+        {
+            try
+            {
+                var settings = await _lidarrSettings.GetSettingsAsync();
+                if (settings.Enabled)
+                {
+                    try
+                    {
+                        var albums = await _lidarrApi.GetAllAlbums(settings.ApiKey, settings.FullUri);
+                        if (albums != null && albums.Any())
+                        {
+                            // Let's remove the old cached data
+                            await _ctx.Database.ExecuteSqlCommandAsync("DELETE FROM LidarrAlbumCache");
+
+                            var artistCache = new List<LidarrAlbumCache>();
+                            foreach (var a in albums)
+                            {
+                                if (a.id > 0)
+                                {
+                                    artistCache.Add(new LidarrAlbumCache
+                                    {
+                                        ArtistId = a.artistId,
+                                        ForeignAlbumId = a.foreignAlbumId,
+                                        ReleaseDate = a.releaseDate,
+                                        TrackCount = a.currentRelease.trackCount,
+                                        Monitored = a.monitored,
+                                        Title = a.title
+                                    });
+                                }
+                            }
+                            await _ctx.LidarrAlbumCache.AddRangeAsync(artistCache);
+
+                            await _ctx.SaveChangesAsync();
+                        }
+                    }
+                    catch (System.Exception ex)
+                    {
+                        _logger.LogError(LoggingEvents.Cacher, ex, "Failed caching queued items from Lidarr Album");
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                _logger.LogInformation(LoggingEvents.LidarrArtistCache, "Lidarr is not setup, cannot cache Album");
+            }
+        }
+
+        public async Task<IEnumerable<LidarrAlbumCache>> GetCachedContent()
+        {
+            return await _ctx.LidarrAlbumCache.ToListAsync();
+        }
+
+        private bool _disposed;
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+                return;
+
+            if (disposing)
+            {
+                _ctx?.Dispose();
+                _lidarrSettings?.Dispose();
+            }
+            _disposed = true;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ombi.Schedule/Jobs/Lidarr/LidarrArtistSync.cs b/src/Ombi.Schedule/Jobs/Lidarr/LidarrArtistSync.cs
new file mode 100644
index 000000000..ac6264e3d
--- /dev/null
+++ b/src/Ombi.Schedule/Jobs/Lidarr/LidarrArtistSync.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Hangfire;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.Extensions.Logging;
+using Ombi.Api.Lidarr;
+using Ombi.Api.Radarr;
+using Ombi.Core.Settings;
+using Ombi.Helpers;
+using Ombi.Settings.Settings.Models.External;
+using Ombi.Store.Context;
+using Ombi.Store.Entities;
+using Serilog;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace Ombi.Schedule.Jobs.Lidarr
+{
+    public class LidarrArtistSync : ILidarrArtistSync
+    {
+        public LidarrArtistSync(ISettingsService<LidarrSettings> lidarr, ILidarrApi lidarrApi, ILogger<LidarrArtistSync> log, IOmbiContext ctx,
+            IBackgroundJobClient background, ILidarrAlbumSync album)
+        {
+            _lidarrSettings = lidarr;
+            _lidarrApi = lidarrApi;
+            _logger = log;
+            _ctx = ctx;
+            _job = background;
+            _albumSync = album;
+            _lidarrSettings.ClearCache();
+        }
+
+        private readonly ISettingsService<LidarrSettings> _lidarrSettings;
+        private readonly ILidarrApi _lidarrApi;
+        private readonly ILogger _logger;
+        private readonly IOmbiContext _ctx;
+        private readonly IBackgroundJobClient _job;
+        private readonly ILidarrAlbumSync _albumSync;
+        
+        public async Task CacheContent()
+        {
+            try
+            {
+                var settings = await _lidarrSettings.GetSettingsAsync();
+                if (settings.Enabled)
+                {
+                    try
+                    {
+                        var artists = await _lidarrApi.GetArtists(settings.ApiKey, settings.FullUri);
+                        if (artists != null && artists.Any())
+                        {
+                            // Let's remove the old cached data
+                            await _ctx.Database.ExecuteSqlCommandAsync("DELETE FROM LidarrArtistCache");
+
+                            var artistCache = new List<LidarrArtistCache>();
+                            foreach (var a in artists)
+                            {
+                                if (a.id > 0)
+                                {
+                                    artistCache.Add(new LidarrArtistCache
+                                    {
+                                        ArtistId = a.id,
+                                        ArtistName = a.artistName,
+                                        ForeignArtistId = a.foreignArtistId,
+                                        Monitored = a.monitored
+                                    });
+                                }
+                            }
+                            await _ctx.LidarrArtistCache.AddRangeAsync(artistCache);
+
+                            await _ctx.SaveChangesAsync();
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(LoggingEvents.Cacher, ex, "Failed caching queued items from Lidarr");
+                    }
+
+                    _job.Enqueue(() => _albumSync.CacheContent());
+                }
+            }
+            catch (Exception)
+            {
+                _logger.LogInformation(LoggingEvents.LidarrArtistCache, "Lidarr is not setup, cannot cache Artist");
+            }
+        }
+
+        public async Task<IEnumerable<LidarrArtistCache>> GetCachedContent()
+        {
+            return await _ctx.LidarrArtistCache.ToListAsync();
+        }
+
+        private bool _disposed;
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+                return;
+
+            if (disposing)
+            {
+                _ctx?.Dispose();
+                _lidarrSettings?.Dispose();
+            }
+            _disposed = true;
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ombi.Schedule/Ombi.Schedule.csproj b/src/Ombi.Schedule/Ombi.Schedule.csproj
index 47e599e80..06cc2bb49 100644
--- a/src/Ombi.Schedule/Ombi.Schedule.csproj
+++ b/src/Ombi.Schedule/Ombi.Schedule.csproj
@@ -27,6 +27,7 @@
   <ItemGroup>
     <ProjectReference Include="..\Ombi.Api.CouchPotato\Ombi.Api.CouchPotato.csproj" />
     <ProjectReference Include="..\Ombi.Api.Emby\Ombi.Api.Emby.csproj" />
+    <ProjectReference Include="..\Ombi.Api.Lidarr\Ombi.Api.Lidarr.csproj" />
     <ProjectReference Include="..\Ombi.Api.Plex\Ombi.Api.Plex.csproj" />
     <ProjectReference Include="..\Ombi.Api.Radarr\Ombi.Api.Radarr.csproj" />
     <ProjectReference Include="..\Ombi.Api.Service\Ombi.Api.Service.csproj" />
diff --git a/src/Ombi.Settings/Settings/Models/JobSettings.cs b/src/Ombi.Settings/Settings/Models/JobSettings.cs
index bb536a685..48c721e29 100644
--- a/src/Ombi.Settings/Settings/Models/JobSettings.cs
+++ b/src/Ombi.Settings/Settings/Models/JobSettings.cs
@@ -13,5 +13,6 @@
         public string SickRageSync { get; set; }
         public string RefreshMetadata { get; set; }
         public string Newsletter { get; set; }
+        public string LidarrArtistSync { get; set; }
     }
 }
\ No newline at end of file
diff --git a/src/Ombi.Settings/Settings/Models/JobSettingsHelper.cs b/src/Ombi.Settings/Settings/Models/JobSettingsHelper.cs
index a5afbeba7..0f8fec5fd 100644
--- a/src/Ombi.Settings/Settings/Models/JobSettingsHelper.cs
+++ b/src/Ombi.Settings/Settings/Models/JobSettingsHelper.cs
@@ -52,6 +52,10 @@ namespace Ombi.Settings.Settings.Models
         {
             return Get(s.RefreshMetadata, Cron.DayInterval(3));
         }
+        public static string LidarrArtistSync(JobSettings s)
+        {
+            return Get(s.LidarrArtistSync, Cron.Hourly(40));
+        }
 
         private static string Get(string settings, string defaultCron)
         {
diff --git a/src/Ombi.Store/Context/IOmbiContext.cs b/src/Ombi.Store/Context/IOmbiContext.cs
index c177784c8..2c4d809b4 100644
--- a/src/Ombi.Store/Context/IOmbiContext.cs
+++ b/src/Ombi.Store/Context/IOmbiContext.cs
@@ -40,6 +40,8 @@ namespace Ombi.Store.Context
         EntityEntry<TEntity> Update<TEntity>(TEntity entity) where TEntity : class;
         DbSet<CouchPotatoCache> CouchPotatoCache { get; set; }
         DbSet<SickRageCache> SickRageCache { get; set; }
+        DbSet<LidarrArtistCache> LidarrArtistCache { get; set; }
+        DbSet<LidarrAlbumCache> LidarrAlbumCache { get; set; }
         DbSet<SickRageEpisodeCache> SickRageEpisodeCache { get; set; }
         DbSet<RequestLog> RequestLogs { get; set; }
         DbSet<RecentlyAddedLog> RecentlyAddedLogs { get; set; }
diff --git a/src/Ombi.Store/Context/OmbiContext.cs b/src/Ombi.Store/Context/OmbiContext.cs
index 03192d998..e93cc89ba 100644
--- a/src/Ombi.Store/Context/OmbiContext.cs
+++ b/src/Ombi.Store/Context/OmbiContext.cs
@@ -45,6 +45,8 @@ namespace Ombi.Store.Context
         public DbSet<Audit> Audit { get; set; }
         public DbSet<Tokens> Tokens { get; set; }
         public DbSet<SonarrCache> SonarrCache { get; set; }
+        public DbSet<LidarrArtistCache> LidarrArtistCache { get; set; }
+        public DbSet<LidarrAlbumCache> LidarrAlbumCache { get; set; }
         public DbSet<SonarrEpisodeCache> SonarrEpisodeCache { get; set; }
         public DbSet<SickRageCache> SickRageCache { get; set; }
         public DbSet<SickRageEpisodeCache> SickRageEpisodeCache { get; set; }
diff --git a/src/Ombi.Store/Entities/LidarrAlbumCache.cs b/src/Ombi.Store/Entities/LidarrAlbumCache.cs
new file mode 100644
index 000000000..5fd1ffcdd
--- /dev/null
+++ b/src/Ombi.Store/Entities/LidarrAlbumCache.cs
@@ -0,0 +1,19 @@
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Ombi.Store.Entities
+{
+    [Table("LidarrAlbumCache")]
+    public class LidarrAlbumCache : Entity
+    {
+        public int ArtistId { get; set; }
+        public string ForeignAlbumId { get; set; }
+        public int TrackCount { get; set; }
+        public DateTime ReleaseDate { get; set; }
+        public bool Monitored { get; set; }
+        public string Title { get; set; }
+
+        [ForeignKey(nameof(ArtistId))]
+        public LidarrArtistCache Artist { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Ombi.Store/Entities/LidarrArtistCache.cs b/src/Ombi.Store/Entities/LidarrArtistCache.cs
new file mode 100644
index 000000000..86daebd2b
--- /dev/null
+++ b/src/Ombi.Store/Entities/LidarrArtistCache.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Ombi.Store.Entities
+{
+    [Table("LidarrArtistCache")]
+    public class LidarrArtistCache : Entity
+    {
+        [ForeignKey(nameof(ArtistId))]
+        public int ArtistId { get; set; }
+        public string ArtistName { get; set; }
+        public string ForeignArtistId { get; set; }
+        public bool Monitored { get; set; }
+        
+        public List<LidarrAlbumCache> Albums { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Ombi.Store/Migrations/20180824202308_LidarrSyncJobs.Designer.cs b/src/Ombi.Store/Migrations/20180824202308_LidarrSyncJobs.Designer.cs
new file mode 100644
index 000000000..5929fe0f5
--- /dev/null
+++ b/src/Ombi.Store/Migrations/20180824202308_LidarrSyncJobs.Designer.cs
@@ -0,0 +1,1095 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Ombi.Store.Context;
+
+namespace Ombi.Store.Migrations
+{
+    [DbContext(typeof(OmbiContext))]
+    [Migration("20180824202308_LidarrSyncJobs")]
+    partial class LidarrSyncJobs
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.1.1-rtm-30846");
+
+            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.Property<string>("Url");
+
+                    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.LidarrAlbumCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ArtistId");
+
+                    b.Property<string>("ForeignAlbumId");
+
+                    b.Property<bool>("Monitored");
+
+                    b.Property<DateTime>("ReleaseDate");
+
+                    b.Property<string>("Title");
+
+                    b.Property<int>("TrackCount");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("LidarrAlbumCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.LidarrArtistCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ArtistId");
+
+                    b.Property<string>("ArtistName");
+
+                    b.Property<string>("ForeignArtistId");
+
+                    b.Property<bool>("Monitored");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LidarrArtistCache");
+                });
+
+            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<int?>("MusicRequestLimit");
+
+                    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?>("EpisodeNumber");
+
+                    b.Property<int?>("SeasonNumber");
+
+                    b.Property<int>("Type");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RecentlyAddedLog");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.Requests.AlbumRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<bool>("Approved");
+
+                    b.Property<string>("ArtistName");
+
+                    b.Property<bool>("Available");
+
+                    b.Property<string>("Cover");
+
+                    b.Property<bool?>("Denied");
+
+                    b.Property<string>("DeniedReason");
+
+                    b.Property<string>("Disk");
+
+                    b.Property<string>("ForeignAlbumId");
+
+                    b.Property<string>("ForeignArtistId");
+
+                    b.Property<DateTime>("MarkedAsApproved");
+
+                    b.Property<DateTime?>("MarkedAsAvailable");
+
+                    b.Property<DateTime>("MarkedAsDenied");
+
+                    b.Property<decimal>("Rating");
+
+                    b.Property<DateTime>("ReleaseDate");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<DateTime>("RequestedDate");
+
+                    b.Property<string>("RequestedUserId");
+
+                    b.Property<string>("Title");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestedUserId");
+
+                    b.ToTable("AlbumRequests");
+                });
+
+            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<DateTime>("MarkedAsApproved");
+
+                    b.Property<DateTime?>("MarkedAsAvailable");
+
+                    b.Property<DateTime>("MarkedAsDenied");
+
+                    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<DateTime>("MarkedAsApproved");
+
+                    b.Property<DateTime?>("MarkedAsAvailable");
+
+                    b.Property<DateTime>("MarkedAsDenied");
+
+                    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>("Background");
+
+                    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.RequestSubscription", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("RequestId");
+
+                    b.Property<int>("RequestType");
+
+                    b.Property<string>("UserId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("RequestSubscription");
+                });
+
+            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.LidarrAlbumCache", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.LidarrArtistCache", "Artist")
+                        .WithMany("Albums")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            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.AlbumRequest", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.OmbiUser", "RequestedUser")
+                        .WithMany()
+                        .HasForeignKey("RequestedUserId");
+                });
+
+            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.RequestSubscription", 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
+        }
+    }
+}
diff --git a/src/Ombi.Store/Migrations/20180824202308_LidarrSyncJobs.cs b/src/Ombi.Store/Migrations/20180824202308_LidarrSyncJobs.cs
new file mode 100644
index 000000000..e741b2294
--- /dev/null
+++ b/src/Ombi.Store/Migrations/20180824202308_LidarrSyncJobs.cs
@@ -0,0 +1,65 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Ombi.Store.Migrations
+{
+    public partial class LidarrSyncJobs : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "LidarrArtistCache",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    ArtistId = table.Column<int>(nullable: false),
+                    ArtistName = table.Column<string>(nullable: true),
+                    ForeignArtistId = table.Column<string>(nullable: true),
+                    Monitored = table.Column<bool>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LidarrArtistCache", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "LidarrAlbumCache",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    ArtistId = table.Column<int>(nullable: false),
+                    ForeignAlbumId = table.Column<string>(nullable: true),
+                    TrackCount = table.Column<int>(nullable: false),
+                    ReleaseDate = table.Column<DateTime>(nullable: false),
+                    Monitored = table.Column<bool>(nullable: false),
+                    Title = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LidarrAlbumCache", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_LidarrAlbumCache_LidarrArtistCache_ArtistId",
+                        column: x => x.ArtistId,
+                        principalTable: "LidarrArtistCache",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LidarrAlbumCache_ArtistId",
+                table: "LidarrAlbumCache",
+                column: "ArtistId");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "LidarrAlbumCache");
+
+            migrationBuilder.DropTable(
+                name: "LidarrArtistCache");
+        }
+    }
+}
diff --git a/src/Ombi.Store/Migrations/OmbiContextModelSnapshot.cs b/src/Ombi.Store/Migrations/OmbiContextModelSnapshot.cs
index cf791febb..893c22edc 100644
--- a/src/Ombi.Store/Migrations/OmbiContextModelSnapshot.cs
+++ b/src/Ombi.Store/Migrations/OmbiContextModelSnapshot.cs
@@ -244,6 +244,48 @@ namespace Ombi.Store.Migrations
                     b.ToTable("GlobalSettings");
                 });
 
+            modelBuilder.Entity("Ombi.Store.Entities.LidarrAlbumCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ArtistId");
+
+                    b.Property<string>("ForeignAlbumId");
+
+                    b.Property<bool>("Monitored");
+
+                    b.Property<DateTime>("ReleaseDate");
+
+                    b.Property<string>("Title");
+
+                    b.Property<int>("TrackCount");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("LidarrAlbumCache");
+                });
+
+            modelBuilder.Entity("Ombi.Store.Entities.LidarrArtistCache", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<int>("ArtistId");
+
+                    b.Property<string>("ArtistName");
+
+                    b.Property<string>("ForeignArtistId");
+
+                    b.Property<bool>("Monitored");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LidarrArtistCache");
+                });
+
             modelBuilder.Entity("Ombi.Store.Entities.NotificationTemplates", b =>
                 {
                     b.Property<int>("Id")
@@ -921,6 +963,14 @@ namespace Ombi.Store.Migrations
                         .HasPrincipalKey("EmbyId");
                 });
 
+            modelBuilder.Entity("Ombi.Store.Entities.LidarrAlbumCache", b =>
+                {
+                    b.HasOne("Ombi.Store.Entities.LidarrArtistCache", "Artist")
+                        .WithMany("Albums")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
             modelBuilder.Entity("Ombi.Store.Entities.NotificationUserId", b =>
                 {
                     b.HasOne("Ombi.Store.Entities.OmbiUser", "User")
diff --git a/src/Ombi/ClientApp/app/interfaces/ISettings.ts b/src/Ombi/ClientApp/app/interfaces/ISettings.ts
index c970ef28b..202dbf2c2 100644
--- a/src/Ombi/ClientApp/app/interfaces/ISettings.ts
+++ b/src/Ombi/ClientApp/app/interfaces/ISettings.ts
@@ -139,6 +139,7 @@ export interface IJobSettings {
   refreshMetadata: string;
   newsletter: string;
   plexRecentlyAddedSync: string;
+  lidarrArtistSync: string;
 }
 
 export interface IIssueSettings extends ISettings {
diff --git a/src/Ombi/ClientApp/app/search/music/albumsearch.component.html b/src/Ombi/ClientApp/app/search/music/albumsearch.component.html
index 317860dbd..cf98c84cc 100644
--- a/src/Ombi/ClientApp/app/search/music/albumsearch.component.html
+++ b/src/Ombi/ClientApp/app/search/music/albumsearch.component.html
@@ -92,16 +92,16 @@
 
         <br/>
 
-        <div class="dropdown" *ngIf="result.available && issueCategories && issuesEnabled">
+        <!-- <div class="dropdown" *ngIf="result.available && issueCategories && issuesEnabled">
             <button class="btn btn-sm btn-primary-outline dropdown-toggle" type="button" data-toggle="dropdown" aria-haspopup="true"
                 aria-expanded="true">
                 <i class="fa fa-plus"></i> Report Issue
                 <span class="caret"></span>
             </button>
             <ul class="dropdown-menu" aria-labelledby="dropdownMenu1">
-                <!-- <li *ngFor="let cat of issueCategories"><a [routerLink]="" (click)="reportIssue(cat, result)">{{cat.value}}</a></li> -->
+                <li *ngFor="let cat of issueCategories"><a [routerLink]="" (click)="reportIssue(cat, result)">{{cat.value}}</a></li>
             </ul>
-        </div>
+        </div> -->
 
     </div>
 
diff --git a/src/Ombi/ClientApp/app/settings/jobs/jobs.component.html b/src/Ombi/ClientApp/app/settings/jobs/jobs.component.html
index 947739d6f..a4dcd6fb3 100644
--- a/src/Ombi/ClientApp/app/settings/jobs/jobs.component.html
+++ b/src/Ombi/ClientApp/app/settings/jobs/jobs.component.html
@@ -22,12 +22,19 @@
                 </div>
 
                 <div class="form-group">
-                    <label for="radarrSync" class="control-label">Radarr Sync</label>              
-                        <input type="text" class="form-control form-control-custom" [ngClass]="{'form-error': form.get('radarrSync').hasError('required')}" id="radarrSync" name="radarrSync" formControlName="radarrSync">
-                        <small *ngIf="form.get('radarrSync').hasError('required')" class="error-text">The Radarr Sync is required</small>
-                        <button type="button" class="btn btn-sm btn-primary-outline" (click)="testCron(form.get('radarrSync')?.value)">Test</button>
-                </div>
+                        <label for="radarrSync" class="control-label">Radarr Sync</label>              
+                            <input type="text" class="form-control form-control-custom" [ngClass]="{'form-error': form.get('radarrSync').hasError('required')}" id="radarrSync" name="radarrSync" formControlName="radarrSync">
+                            <small *ngIf="form.get('radarrSync').hasError('required')" class="error-text">The Radarr Sync is required</small>
+                            <button type="button" class="btn btn-sm btn-primary-outline" (click)="testCron(form.get('radarrSync')?.value)">Test</button>
+                    </div>
 
+                    <div class="form-group">
+                            <label for="lidarrArtistSync" class="control-label">Lidarr Sync</label>              
+                                <input type="text" class="form-control form-control-custom" [ngClass]="{'form-error': form.get('lidarrArtistSync').hasError('required')}" id="lidarrArtistSync" name="lidarrArtistSync" formControlName="lidarrArtistSync">
+                                <small *ngIf="form.get('lidarrArtistSync').hasError('required')" class="error-text">The Lidarr Sync is required</small>
+                                <button type="button" class="btn btn-sm btn-primary-outline" (click)="testCron(form.get('lidarrArtistSync')?.value)">Test</button>
+                        </div>
+        
                 <div class="form-group">
                     <label for="couchPotatoSync" class="control-label">CouchPotato Sync</label>              
                         <input type="text" class="form-control form-control-custom" [ngClass]="{'form-error': form.get('radarrSync').hasError('required')}" id="couchPotatoSync" name="couchPotatoSync" formControlName="couchPotatoSync">
diff --git a/src/Ombi/Controllers/SettingsController.cs b/src/Ombi/Controllers/SettingsController.cs
index 5d99e391f..84192c53c 100644
--- a/src/Ombi/Controllers/SettingsController.cs
+++ b/src/Ombi/Controllers/SettingsController.cs
@@ -506,6 +506,7 @@ namespace Ombi.Controllers
             j.RefreshMetadata = j.RefreshMetadata.HasValue() ? j.RefreshMetadata : JobSettingsHelper.RefreshMetadata(j);
             j.PlexRecentlyAddedSync = j.PlexRecentlyAddedSync.HasValue() ? j.PlexRecentlyAddedSync : JobSettingsHelper.PlexRecentlyAdded(j);
             j.Newsletter = j.Newsletter.HasValue() ? j.Newsletter : JobSettingsHelper.Newsletter(j);
+            j.LidarrArtistSync = j.LidarrArtistSync.HasValue() ? j.LidarrArtistSync : JobSettingsHelper.LidarrArtistSync(j);
  
             return j;
         }