Removed Core/Model Core/Provider

NzbDrone.Core/DataAugmentation/Xem/Model/XemResult.cs

@@ -0,0 +1,9 @@
+namespace NzbDrone.Core.DataAugmentation.Xem.Model
+{
+    public class XemResult<T>
+    {
+        public string Result { get; set; }
+        public T Data { get; set; }
+        public string Message { get; set; }
+    }
+}

NzbDrone.Core/DataAugmentation/Xem/Model/XemSceneTvdbMapping.cs

@@ -0,0 +1,8 @@
+namespace NzbDrone.Core.DataAugmentation.Xem.Model
+{
+    public class XemSceneTvdbMapping
+    {
+        public XemValues Scene { get; set; }
+        public XemValues Tvdb { get; set; }
+    }
+}

NzbDrone.Core/DataAugmentation/Xem/Model/XemValues.cs

@@ -0,0 +1,9 @@
+namespace NzbDrone.Core.DataAugmentation.Xem.Model
+{
+    public class XemValues
+    {
+        public int Season { get; set; }
+        public int Episode { get; set; }
+        public int Absolute { get; set; }
+    }
+}

NzbDrone.Core/DataAugmentation/Xem/UpdateXemMappingsCommand.cs

@@ -0,0 +1,9 @@
+using NzbDrone.Core.Messaging.Commands;
+
+namespace NzbDrone.Core.DataAugmentation.Xem
+{
+    public class UpdateXemMappingsCommand : Command
+    {
+   
+    }
+}

NzbDrone.Core/DataAugmentation/Xem/XemProxy.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NLog;
+using NzbDrone.Core.DataAugmentation.Xem.Model;
+using NzbDrone.Core.Rest;
+using RestSharp;
+
+namespace NzbDrone.Core.DataAugmentation.Xem
+{
+    public interface IXemProxy
+    {
+        List<int> GetXemSeriesIds();
+        List<XemSceneTvdbMapping> GetSceneTvdbMappings(int id);
+    }
+
+    public class XemProxy : IXemProxy
+    {
+        private readonly Logger _logger;
+
+        private const string XEM_BASE_URL = "http://thexem.de/map/";
+
+        public XemProxy(Logger logger)
+        {
+            _logger = logger;
+        }
+
+
+        private static RestRequest BuildRequest(string resource)
+        {
+            var req = new RestRequest(resource, Method.GET);
+            req.AddParameter("origin", "tvdb");
+            return req;
+        }
+
+        public List<int> GetXemSeriesIds()
+        {
+            _logger.Trace("Fetching Series IDs from");
+
+            var restClient = new RestClient(XEM_BASE_URL);
+
+            var request = BuildRequest("havemap");
+
+            var response = restClient.ExecuteAndValidate<XemResult<List<int>>>(request);
+            CheckForFailureResult(response);
+
+            return response.Data.ToList();
+        }
+
+        public List<XemSceneTvdbMapping> GetSceneTvdbMappings(int id)
+        {
+            _logger.Trace("Fetching Mappings for: {0}", id);
+            var url = String.Format("{0}all?id={1}&origin=tvdb", XEM_BASE_URL, id);
+
+
+            var restClient = new RestClient(XEM_BASE_URL);
+
+            var request = BuildRequest("all");
+            request.AddParameter("id", id);
+
+            var response = restClient.ExecuteAndValidate<XemResult<List<XemSceneTvdbMapping>>>(request);
+            CheckForFailureResult(response);
+
+            return response.Data;
+        }
+
+        private static void CheckForFailureResult<T>(XemResult<T> response)
+        {
+            if (response.Result.Equals("failure", StringComparison.InvariantCultureIgnoreCase) &&
+                !response.Message.Contains("no show with the tvdb_id"))
+            {
+                throw new Exception("Error response received from Xem: " + response.Message);
+            }
+        }
+    }
+}

NzbDrone.Core/DataAugmentation/Xem/XemService.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NLog;
+using NzbDrone.Common.Cache;
+using NzbDrone.Core.Lifecycle;
+using NzbDrone.Core.Messaging.Commands;
+using NzbDrone.Core.Messaging.Events;
+using NzbDrone.Core.Tv;
+using NzbDrone.Core.Tv.Events;
+
+namespace NzbDrone.Core.DataAugmentation.Xem
+{
+    public class XemService : IExecute<UpdateXemMappingsCommand>, IHandle<SeriesUpdatedEvent>, IHandleAsync<ApplicationStartedEvent>
+    {
+        private readonly IEpisodeService _episodeService;
+        private readonly IXemProxy _xemProxy;
+        private readonly ISeriesService _seriesService;
+        private readonly Logger _logger;
+        private readonly ICached<bool> _cache;
+
+        public XemService(IEpisodeService episodeService,
+                           IXemProxy xemProxy,
+                           ISeriesService seriesService, ICacheManger cacheManger, Logger logger)
+        {
+            if (seriesService == null) throw new ArgumentNullException("seriesService");
+            _episodeService = episodeService;
+            _xemProxy = xemProxy;
+            _seriesService = seriesService;
+            _logger = logger;
+            _logger = logger;
+            _cache = cacheManger.GetCache<bool>(GetType());
+        }
+
+
+        public void Execute(UpdateXemMappingsCommand message)
+        {
+            UpdateMappings();
+        }
+
+        public void Handle(SeriesUpdatedEvent message)
+        {
+            UpdateMappings(message.Series);
+        }
+
+        public void HandleAsync(ApplicationStartedEvent message)
+        {
+            GetXemSeriesIds();
+        }
+
+        private void UpdateMappings()
+        {
+            _logger.Trace("Starting scene numbering update");
+
+            try
+            {
+                var ids = GetXemSeriesIds();
+                var series = _seriesService.GetAllSeries();
+                var wantedSeries = series.Where(s => ids.Contains(s.TvdbId)).ToList();
+
+                foreach (var ser in wantedSeries)
+                {
+                    PerformUpdate(ser);
+                }
+
+                _logger.Trace("Completed scene numbering update");
+            }
+
+            catch (Exception ex)
+            {
+                _logger.WarnException("Error updating Scene Mappings", ex);
+                throw;
+            }
+        }
+
+        private void UpdateMappings(Series series)
+        {
+            if (!_cache.Find(series.TvdbId.ToString()))
+            {
+                _logger.Trace("Scene numbering is not available for {0} [{1}]", series.Title, series.TvdbId);
+                return;
+            }
+
+            PerformUpdate(series);
+        }
+
+        private void PerformUpdate(Series series)
+        {
+            _logger.Trace("Updating scene numbering mapping for: {0}", series);
+            try
+            {
+                var episodesToUpdate = new List<Episode>();
+                var mappings = _xemProxy.GetSceneTvdbMappings(series.TvdbId);
+
+                if (!mappings.Any())
+                {
+                    _logger.Trace("Mappings for: {0} are empty, skipping", series);
+                    _cache.Remove(series.TvdbId.ToString());
+                    return;
+                }
+
+                var episodes = _episodeService.GetEpisodeBySeries(series.Id);
+
+                foreach (var mapping in mappings)
+                {
+                    _logger.Trace("Setting scene numbering mappings for {0} S{1:00}E{2:00}", series, mapping.Tvdb.Season, mapping.Tvdb.Episode);
+
+                    var episode = episodes.SingleOrDefault(e => e.SeasonNumber == mapping.Tvdb.Season && e.EpisodeNumber == mapping.Tvdb.Episode);
+
+                    if (episode == null)
+                    {
+                        _logger.Trace("Information hasn't been added to TheTVDB yet, skipping.");
+                        continue;
+                    }
+
+                    episode.AbsoluteEpisodeNumber = mapping.Scene.Absolute;
+                    episode.SceneSeasonNumber = mapping.Scene.Season;
+                    episode.SceneEpisodeNumber = mapping.Scene.Episode;
+                    episodesToUpdate.Add(episode);
+                }
+
+                _logger.Trace("Committing scene numbering mappings to database for: {0}", series);
+                _episodeService.UpdateEpisodes(episodesToUpdate);
+
+                _logger.Trace("Setting UseSceneMapping for {0}", series);
+                series.UseSceneNumbering = true;
+                _seriesService.UpdateSeries(series);
+            }
+
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error updating scene numbering mappings for: " + series, ex);
+            }
+        }
+
+        private List<int> GetXemSeriesIds()
+        {
+            _cache.Clear();
+
+            var ids = _xemProxy.GetXemSeriesIds();
+
+            foreach (var id in ids)
+            {
+                _cache.Set(id.ToString(), true);
+            }
+
+            return ids;
+        }
+    }
+}