From 3eb4091808735858b01855d298226d239be464af Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Thu, 3 Nov 2016 02:37:52 -0400
Subject: move additional classes to new server lib

---
 .../Library/Validators/ArtistsPostScanTask.cs      |  44 ++++++
 .../Library/Validators/ArtistsValidator.cs         |  84 ++++++++++
 .../Library/Validators/GameGenresPostScanTask.cs   |  45 ++++++
 .../Library/Validators/GameGenresValidator.cs      |  74 +++++++++
 .../Library/Validators/GenresPostScanTask.cs       |  42 +++++
 .../Library/Validators/GenresValidator.cs          |  75 +++++++++
 .../Library/Validators/MusicGenresPostScanTask.cs  |  45 ++++++
 .../Library/Validators/MusicGenresValidator.cs     |  75 +++++++++
 .../Library/Validators/PeopleValidator.cs          | 172 +++++++++++++++++++++
 .../Library/Validators/StudiosPostScanTask.cs      |  45 ++++++
 .../Library/Validators/StudiosValidator.cs         |  74 +++++++++
 .../Library/Validators/YearsPostScanTask.cs        |  55 +++++++
 12 files changed, 830 insertions(+)
 create mode 100644 Emby.Server.Implementations/Library/Validators/ArtistsPostScanTask.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/GameGenresPostScanTask.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/GameGenresValidator.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/GenresPostScanTask.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/GenresValidator.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/MusicGenresPostScanTask.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/MusicGenresValidator.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/StudiosPostScanTask.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
 create mode 100644 Emby.Server.Implementations/Library/Validators/YearsPostScanTask.cs

(limited to 'Emby.Server.Implementations/Library/Validators')

diff --git a/Emby.Server.Implementations/Library/Validators/ArtistsPostScanTask.cs b/Emby.Server.Implementations/Library/Validators/ArtistsPostScanTask.cs
new file mode 100644
index 000000000..4d718dbee
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/ArtistsPostScanTask.cs
@@ -0,0 +1,44 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    /// <summary>
+    /// Class ArtistsPostScanTask
+    /// </summary>
+    public class ArtistsPostScanTask : ILibraryPostScanTask
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+        private readonly ILogger _logger;
+        private readonly IItemRepository _itemRepo;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArtistsPostScanTask" /> class.
+        /// </summary>
+        /// <param name="libraryManager">The library manager.</param>
+        public ArtistsPostScanTask(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            return new ArtistsValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs b/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
new file mode 100644
index 000000000..643c5970e
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
@@ -0,0 +1,84 @@
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    /// <summary>
+    /// Class ArtistsValidator
+    /// </summary>
+    public class ArtistsValidator
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+        private readonly IItemRepository _itemRepo;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArtistsPostScanTask" /> class.
+        /// </summary>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="logger">The logger.</param>
+        public ArtistsValidator(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            var names = _itemRepo.GetAllArtistNames();
+
+            var numComplete = 0;
+            var count = names.Count;
+
+            foreach (var name in names)
+            {
+                try
+                {
+                    var item = _libraryManager.GetArtist(name);
+
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    // Don't clutter the log
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error refreshing {0}", ex, name);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= count;
+                percent *= 100;
+
+                progress.Report(percent);
+            }
+
+            progress.Report(100);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/GameGenresPostScanTask.cs b/Emby.Server.Implementations/Library/Validators/GameGenresPostScanTask.cs
new file mode 100644
index 000000000..ee6c4461c
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/GameGenresPostScanTask.cs
@@ -0,0 +1,45 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    /// <summary>
+    /// Class GameGenresPostScanTask
+    /// </summary>
+    public class GameGenresPostScanTask : ILibraryPostScanTask
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+        private readonly ILogger _logger;
+        private readonly IItemRepository _itemRepo;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GameGenresPostScanTask" /> class.
+        /// </summary>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="logger">The logger.</param>
+        public GameGenresPostScanTask(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            return new GameGenresValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/GameGenresValidator.cs b/Emby.Server.Implementations/Library/Validators/GameGenresValidator.cs
new file mode 100644
index 000000000..b1820bb91
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/GameGenresValidator.cs
@@ -0,0 +1,74 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    class GameGenresValidator
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+        private readonly IItemRepository _itemRepo;
+
+        public GameGenresValidator(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            var names = _itemRepo.GetGameGenreNames();
+
+            var numComplete = 0;
+            var count = names.Count;
+
+            foreach (var name in names)
+            {
+                try
+                {
+                    var item = _libraryManager.GetGameGenre(name);
+
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    // Don't clutter the log
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error refreshing {0}", ex, name);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= count;
+                percent *= 100;
+
+                progress.Report(percent);
+            }
+
+            progress.Report(100);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/GenresPostScanTask.cs b/Emby.Server.Implementations/Library/Validators/GenresPostScanTask.cs
new file mode 100644
index 000000000..be46decfb
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/GenresPostScanTask.cs
@@ -0,0 +1,42 @@
+using MediaBrowser.Controller.Library;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    public class GenresPostScanTask : ILibraryPostScanTask
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+        private readonly ILogger _logger;
+        private readonly IItemRepository _itemRepo;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArtistsPostScanTask" /> class.
+        /// </summary>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="logger">The logger.</param>
+        public GenresPostScanTask(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            return new GenresValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/GenresValidator.cs b/Emby.Server.Implementations/Library/Validators/GenresValidator.cs
new file mode 100644
index 000000000..d8956f78a
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/GenresValidator.cs
@@ -0,0 +1,75 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    class GenresValidator
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+        private readonly IItemRepository _itemRepo;
+
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        public GenresValidator(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            var names = _itemRepo.GetGenreNames();
+
+            var numComplete = 0;
+            var count = names.Count;
+
+            foreach (var name in names)
+            {
+                try
+                {
+                    var item = _libraryManager.GetGenre(name);
+
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    // Don't clutter the log
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error refreshing {0}", ex, name);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= count;
+                percent *= 100;
+
+                progress.Report(percent);
+            }
+
+            progress.Report(100);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/MusicGenresPostScanTask.cs b/Emby.Server.Implementations/Library/Validators/MusicGenresPostScanTask.cs
new file mode 100644
index 000000000..cd4021548
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/MusicGenresPostScanTask.cs
@@ -0,0 +1,45 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    /// <summary>
+    /// Class MusicGenresPostScanTask
+    /// </summary>
+    public class MusicGenresPostScanTask : ILibraryPostScanTask
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+        private readonly ILogger _logger;
+        private readonly IItemRepository _itemRepo;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArtistsPostScanTask" /> class.
+        /// </summary>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="logger">The logger.</param>
+        public MusicGenresPostScanTask(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            return new MusicGenresValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/MusicGenresValidator.cs b/Emby.Server.Implementations/Library/Validators/MusicGenresValidator.cs
new file mode 100644
index 000000000..983c881b7
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/MusicGenresValidator.cs
@@ -0,0 +1,75 @@
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    class MusicGenresValidator
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+        private readonly IItemRepository _itemRepo;
+
+        public MusicGenresValidator(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            var names = _itemRepo.GetMusicGenreNames();
+
+            var numComplete = 0;
+            var count = names.Count;
+
+            foreach (var name in names)
+            {
+                try
+                {
+                    var item = _libraryManager.GetMusicGenre(name);
+
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    // Don't clutter the log
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error refreshing {0}", ex, name);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= count;
+                percent *= 100;
+
+                progress.Report(percent);
+            }
+
+            progress.Report(100);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
new file mode 100644
index 000000000..813f07fff
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
@@ -0,0 +1,172 @@
+using MediaBrowser.Common.Progress;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Model.IO;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    /// <summary>
+    /// Class PeopleValidator
+    /// </summary>
+    public class PeopleValidator
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        private readonly IServerConfigurationManager _config;
+        private readonly IFileSystem _fileSystem;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PeopleValidator" /> class.
+        /// </summary>
+        /// <param name="libraryManager">The library manager.</param>
+        /// <param name="logger">The logger.</param>
+        public PeopleValidator(ILibraryManager libraryManager, ILogger logger, IServerConfigurationManager config, IFileSystem fileSystem)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _config = config;
+            _fileSystem = fileSystem;
+        }
+
+        private bool DownloadMetadata(PersonInfo i, PeopleMetadataOptions options)
+        {
+            if (i.IsType(PersonType.Actor))
+            {
+                return options.DownloadActorMetadata;
+            }
+            if (i.IsType(PersonType.Director))
+            {
+                return options.DownloadDirectorMetadata;
+            }
+            if (i.IsType(PersonType.Composer))
+            {
+                return options.DownloadComposerMetadata;
+            }
+            if (i.IsType(PersonType.Writer))
+            {
+                return options.DownloadWriterMetadata;
+            }
+            if (i.IsType(PersonType.Producer))
+            {
+                return options.DownloadProducerMetadata;
+            }
+            if (i.IsType(PersonType.GuestStar))
+            {
+                return options.DownloadGuestStarMetadata;
+            }
+
+            return options.DownloadOtherPeopleMetadata;
+        }
+
+        /// <summary>
+        /// Validates the people.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <param name="progress">The progress.</param>
+        /// <returns>Task.</returns>
+        public async Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
+        {
+            var innerProgress = new ActionableProgress<double>();
+
+            innerProgress.RegisterAction(pct => progress.Report(pct * .15));
+
+            var peopleOptions = _config.Configuration.PeopleMetadataOptions;
+
+            var people = _libraryManager.GetPeople(new InternalPeopleQuery());
+
+            var dict = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var person in people)
+            {
+                var isMetadataEnabled = DownloadMetadata(person, peopleOptions);
+
+                bool currentValue;
+                if (dict.TryGetValue(person.Name, out currentValue))
+                {
+                    if (!currentValue && isMetadataEnabled)
+                    {
+                        dict[person.Name] = true;
+                    }
+                }
+                else
+                {
+                    dict[person.Name] = isMetadataEnabled;
+                }
+            }
+
+            var numComplete = 0;
+
+            _logger.Debug("Will refresh {0} people", dict.Count);
+
+            var numPeople = dict.Count;
+
+            foreach (var person in dict)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                try
+                {
+                    var item = _libraryManager.GetPerson(person.Key);
+
+                    var hasMetdata = !string.IsNullOrWhiteSpace(item.Overview);
+                    var performFullRefresh = !hasMetdata && (DateTime.UtcNow - item.DateLastRefreshed).TotalDays >= 30;
+
+                    var defaultMetadataRefreshMode = performFullRefresh
+                        ? MetadataRefreshMode.FullRefresh
+                        : MetadataRefreshMode.Default;
+
+                    var imageRefreshMode = performFullRefresh
+                        ? ImageRefreshMode.FullRefresh
+                        : ImageRefreshMode.Default;
+
+                    var options = new MetadataRefreshOptions(_fileSystem)
+                    {
+                        MetadataRefreshMode = person.Value ? defaultMetadataRefreshMode : MetadataRefreshMode.ValidationOnly,
+                        ImageRefreshMode = person.Value ? imageRefreshMode : ImageRefreshMode.ValidationOnly,
+                        ForceSave = performFullRefresh
+                    };
+
+                    await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    throw;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error validating IBN entry {0}", ex, person);
+                }
+
+                // Update progress
+                numComplete++;
+                double percent = numComplete;
+                percent /= numPeople;
+
+                progress.Report(100 * percent);
+            }
+
+            progress.Report(100);
+
+            _logger.Info("People validation complete");
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/StudiosPostScanTask.cs b/Emby.Server.Implementations/Library/Validators/StudiosPostScanTask.cs
new file mode 100644
index 000000000..d23efb6d3
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/StudiosPostScanTask.cs
@@ -0,0 +1,45 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    /// <summary>
+    /// Class MusicGenresPostScanTask
+    /// </summary>
+    public class StudiosPostScanTask : ILibraryPostScanTask
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+
+        private readonly ILogger _logger;
+        private readonly IItemRepository _itemRepo;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ArtistsPostScanTask" /> class.
+        /// </summary>
+        /// <param name="libraryManager">The library manager.</param>
+        public StudiosPostScanTask(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            return new StudiosValidator(_libraryManager, _logger, _itemRepo).Run(progress, cancellationToken);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs b/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
new file mode 100644
index 000000000..6faab7bb9
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
@@ -0,0 +1,74 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Persistence;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    class StudiosValidator
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+
+        private readonly IItemRepository _itemRepo;
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        public StudiosValidator(ILibraryManager libraryManager, ILogger logger, IItemRepository itemRepo)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+            _itemRepo = itemRepo;
+        }
+
+        /// <summary>
+        /// Runs the specified progress.
+        /// </summary>
+        /// <param name="progress">The progress.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            var names = _itemRepo.GetStudioNames();
+
+            var numComplete = 0;
+            var count = names.Count;
+
+            foreach (var name in names)
+            {
+                try
+                {
+                    var item = _libraryManager.GetStudio(name);
+
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    // Don't clutter the log
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error refreshing {0}", ex, name);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= count;
+                percent *= 100;
+
+                progress.Report(percent);
+            }
+
+            progress.Report(100);
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Library/Validators/YearsPostScanTask.cs b/Emby.Server.Implementations/Library/Validators/YearsPostScanTask.cs
new file mode 100644
index 000000000..ae43c77f0
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/YearsPostScanTask.cs
@@ -0,0 +1,55 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Emby.Server.Implementations.Library.Validators
+{
+    public class YearsPostScanTask : ILibraryPostScanTask
+    {
+        private readonly ILibraryManager _libraryManager;
+        private readonly ILogger _logger;
+
+        public YearsPostScanTask(ILibraryManager libraryManager, ILogger logger)
+        {
+            _libraryManager = libraryManager;
+            _logger = logger;
+        }
+
+        public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+        {
+            var yearNumber = 1900;
+            var maxYear = DateTime.UtcNow.Year + 3;
+            var count = maxYear - yearNumber + 1;
+            var numComplete = 0;
+
+            while (yearNumber < maxYear)
+            {
+                try
+                {
+                    var year = _libraryManager.GetYear(yearNumber);
+
+                    await year.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    // Don't clutter the log
+                    break;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error refreshing year {0}", ex, yearNumber);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= count;
+                percent *= 100;
+
+                progress.Report(percent);
+                yearNumber++;
+            }
+        }
+    }
+}
-- 
cgit v1.2.3


From 01fc207b62151a858c0d7edb802a24690505bb95 Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Thu, 10 Nov 2016 20:37:20 -0500
Subject: update portable components

---
 .../Serialization/JsonSerializer.cs                | 227 ++++++
 Emby.Common.Implementations/project.json           |  45 +-
 .../Emby.Server.Implementations.csproj             |   4 +
 .../HttpServer/HttpResultFactory.cs                | 847 +++++++++++++++++++++
 .../Library/Validators/PeopleValidator.cs          |  18 +-
 .../HttpServer/HttpListenerHost.cs                 |  60 +-
 .../HttpServer/HttpResultFactory.cs                | 835 --------------------
 .../SocketSharp/WebSocketSharpRequest.cs           |  32 +-
 .../MediaBrowser.Server.Implementations.csproj     |  13 +-
 .../Serialization/JsonSerializer.cs                | 227 ------
 .../packages.config                                |   1 +
 .../ApplicationHost.cs                             |   3 +-
 12 files changed, 1173 insertions(+), 1139 deletions(-)
 create mode 100644 Emby.Common.Implementations/Serialization/JsonSerializer.cs
 create mode 100644 Emby.Server.Implementations/HttpServer/HttpResultFactory.cs
 delete mode 100644 MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
 delete mode 100644 MediaBrowser.Server.Implementations/Serialization/JsonSerializer.cs

(limited to 'Emby.Server.Implementations/Library/Validators')

diff --git a/Emby.Common.Implementations/Serialization/JsonSerializer.cs b/Emby.Common.Implementations/Serialization/JsonSerializer.cs
new file mode 100644
index 000000000..c9db33689
--- /dev/null
+++ b/Emby.Common.Implementations/Serialization/JsonSerializer.cs
@@ -0,0 +1,227 @@
+using System;
+using System.IO;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Serialization;
+
+namespace Emby.Common.Implementations.Serialization
+{
+    /// <summary>
+    /// Provides a wrapper around third party json serialization.
+    /// </summary>
+    public class JsonSerializer : IJsonSerializer
+    {
+        private readonly IFileSystem _fileSystem;
+        private readonly ILogger _logger;
+
+        public JsonSerializer(IFileSystem fileSystem, ILogger logger)
+        {
+            _fileSystem = fileSystem;
+            _logger = logger;
+            Configure();
+        }
+
+        /// <summary>
+        /// Serializes to stream.
+        /// </summary>
+        /// <param name="obj">The obj.</param>
+        /// <param name="stream">The stream.</param>
+        /// <exception cref="System.ArgumentNullException">obj</exception>
+        public void SerializeToStream(object obj, Stream stream)
+        {
+            if (obj == null)
+            {
+                throw new ArgumentNullException("obj");
+            }
+
+            if (stream == null)
+            {
+                throw new ArgumentNullException("stream");
+            }
+
+            ServiceStack.Text.JsonSerializer.SerializeToStream(obj, obj.GetType(), stream);
+        }
+
+        /// <summary>
+        /// Serializes to file.
+        /// </summary>
+        /// <param name="obj">The obj.</param>
+        /// <param name="file">The file.</param>
+        /// <exception cref="System.ArgumentNullException">obj</exception>
+        public void SerializeToFile(object obj, string file)
+        {
+            if (obj == null)
+            {
+                throw new ArgumentNullException("obj");
+            }
+
+            if (string.IsNullOrEmpty(file))
+            {
+                throw new ArgumentNullException("file");
+            }
+
+			using (Stream stream = _fileSystem.GetFileStream(file, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read))
+            {
+                SerializeToStream(obj, stream);
+            }
+        }
+
+        private Stream OpenFile(string path)
+        {
+            _logger.Debug("Deserializing file {0}", path);
+            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 131072);
+        }
+
+        /// <summary>
+        /// Deserializes from file.
+        /// </summary>
+        /// <param name="type">The type.</param>
+        /// <param name="file">The file.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">type</exception>
+        public object DeserializeFromFile(Type type, string file)
+        {
+            if (type == null)
+            {
+                throw new ArgumentNullException("type");
+            }
+
+            if (string.IsNullOrEmpty(file))
+            {
+                throw new ArgumentNullException("file");
+            }
+
+            using (Stream stream = OpenFile(file))
+            {
+                return DeserializeFromStream(stream, type);
+            }
+        }
+
+        /// <summary>
+        /// Deserializes from file.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="file">The file.</param>
+        /// <returns>``0.</returns>
+        /// <exception cref="System.ArgumentNullException">file</exception>
+        public T DeserializeFromFile<T>(string file)
+            where T : class
+        {
+            if (string.IsNullOrEmpty(file))
+            {
+                throw new ArgumentNullException("file");
+            }
+
+            using (Stream stream = OpenFile(file))
+            {
+                return DeserializeFromStream<T>(stream);
+            }
+        }
+
+        /// <summary>
+        /// Deserializes from stream.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="stream">The stream.</param>
+        /// <returns>``0.</returns>
+        /// <exception cref="System.ArgumentNullException">stream</exception>
+        public T DeserializeFromStream<T>(Stream stream)
+        {
+            if (stream == null)
+            {
+                throw new ArgumentNullException("stream");
+            }
+
+            return ServiceStack.Text.JsonSerializer.DeserializeFromStream<T>(stream);
+        }
+
+        /// <summary>
+        /// Deserializes from string.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="text">The text.</param>
+        /// <returns>``0.</returns>
+        /// <exception cref="System.ArgumentNullException">text</exception>
+        public T DeserializeFromString<T>(string text)
+        {
+            if (string.IsNullOrEmpty(text))
+            {
+                throw new ArgumentNullException("text");
+            }
+
+            return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(text);
+        }
+
+        /// <summary>
+        /// Deserializes from stream.
+        /// </summary>
+        /// <param name="stream">The stream.</param>
+        /// <param name="type">The type.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">stream</exception>
+        public object DeserializeFromStream(Stream stream, Type type)
+        {
+            if (stream == null)
+            {
+                throw new ArgumentNullException("stream");
+            }
+
+            if (type == null)
+            {
+                throw new ArgumentNullException("type");
+            }
+
+            return ServiceStack.Text.JsonSerializer.DeserializeFromStream(type, stream);
+        }
+
+        /// <summary>
+        /// Configures this instance.
+        /// </summary>
+        private void Configure()
+        {
+            ServiceStack.Text.JsConfig.DateHandler = ServiceStack.Text.DateHandler.ISO8601;
+            ServiceStack.Text.JsConfig.ExcludeTypeInfo = true;
+            ServiceStack.Text.JsConfig.IncludeNullValues = false;
+            ServiceStack.Text.JsConfig.AlwaysUseUtc = true;
+            ServiceStack.Text.JsConfig.AssumeUtc = true;
+        }
+
+        /// <summary>
+        /// Deserializes from string.
+        /// </summary>
+        /// <param name="json">The json.</param>
+        /// <param name="type">The type.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">json</exception>
+        public object DeserializeFromString(string json, Type type)
+        {
+            if (string.IsNullOrEmpty(json))
+            {
+                throw new ArgumentNullException("json");
+            }
+
+            if (type == null)
+            {
+                throw new ArgumentNullException("type");
+            }
+
+            return ServiceStack.Text.JsonSerializer.DeserializeFromString(json, type);
+        }
+
+        /// <summary>
+        /// Serializes to string.
+        /// </summary>
+        /// <param name="obj">The obj.</param>
+        /// <returns>System.String.</returns>
+        /// <exception cref="System.ArgumentNullException">obj</exception>
+        public string SerializeToString(object obj)
+        {
+            if (obj == null)
+            {
+                throw new ArgumentNullException("obj");
+            }
+
+            return ServiceStack.Text.JsonSerializer.SerializeToString(obj, obj.GetType());
+        }
+    }
+}
diff --git a/Emby.Common.Implementations/project.json b/Emby.Common.Implementations/project.json
index 2b2357e38..dd304606b 100644
--- a/Emby.Common.Implementations/project.json
+++ b/Emby.Common.Implementations/project.json
@@ -2,7 +2,7 @@
   "version": "1.0.0-*",
 
   "dependencies": {
-    
+
   },
 
   "frameworks": {
@@ -19,46 +19,49 @@
         "System.Text.Encoding": "4.0.0.0",
         "System.Threading": "4.0.0.0",
         "System.Threading.Tasks": "4.0.0.0",
-		"System.Xml.ReaderWriter": "4.0.0"
+        "System.Xml.ReaderWriter": "4.0.0"
       },
       "dependencies": {
         "SimpleInjector": "3.2.4",
+        "ServiceStack.Text": "4.5.4",
         "NLog": "4.4.0-betaV15",
         "MediaBrowser.Model": {
           "target": "project"
         },
         "MediaBrowser.Common": {
           "target": "project"
-        }      
-	}
+        }
+      }
     },
     "netstandard1.6": {
       "imports": "dnxcore50",
       "dependencies": {
         "NETStandard.Library": "1.6.0",
-		"System.IO.FileSystem.DriveInfo": "4.0.0",
-		"System.Diagnostics.Process": "4.1.0",
-		"System.Threading.Timer": "4.0.1",
-		"System.Net.Requests": "4.0.11",
-		"System.Xml.ReaderWriter": "4.0.11",
-		"System.Xml.XmlSerializer": "4.0.11",
-		"System.Net.Http": "4.1.0",
-		"System.Net.Primitives": "4.0.11",
-		"System.Net.Sockets": "4.1.0",
-		"System.Net.NetworkInformation": "4.1.0",
-		"System.Net.NameResolution": "4.0.0",
-		"System.Runtime.InteropServices.RuntimeInformation": "4.0.0",
-		"System.Reflection": "4.1.0",
-		"System.Reflection.Primitives": "4.0.1",
-		"System.Runtime.Loader": "4.0.0",
-		"SimpleInjector": "3.2.4",
+        "System.IO.FileSystem.DriveInfo": "4.0.0",
+        "System.Diagnostics.Process": "4.1.0",
+        "System.Threading.Timer": "4.0.1",
+        "System.Net.Requests": "4.0.11",
+        "System.Xml.ReaderWriter": "4.0.11",
+        "System.Xml.XmlSerializer": "4.0.11",
+        "System.Net.Http": "4.1.0",
+        "System.Net.Primitives": "4.0.11",
+        "System.Net.Sockets": "4.1.0",
+        "System.Net.NetworkInformation": "4.1.0",
+        "System.Net.NameResolution": "4.0.0",
+        "System.Runtime.InteropServices.RuntimeInformation": "4.0.0",
+        "System.Reflection": "4.1.0",
+        "System.Reflection.Primitives": "4.0.1",
+        "System.Runtime.Loader": "4.0.0",
+        "SimpleInjector": "3.2.4",
+        "ServiceStack.Text.Core": "1.0.27",
         "NLog": "4.4.0-betaV15",
         "MediaBrowser.Model": {
           "target": "project"
         },
         "MediaBrowser.Common": {
           "target": "project"
-        }      }
+        }
+      }
     }
   }
 }
diff --git a/Emby.Server.Implementations/Emby.Server.Implementations.csproj b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
index 7e885b779..3f55bd7fb 100644
--- a/Emby.Server.Implementations/Emby.Server.Implementations.csproj
+++ b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
@@ -69,6 +69,7 @@
     <Compile Include="FileOrganization\OrganizerScheduledTask.cs" />
     <Compile Include="FileOrganization\TvFolderOrganizer.cs" />
     <Compile Include="HttpServer\GetSwaggerResource.cs" />
+    <Compile Include="HttpServer\HttpResultFactory.cs" />
     <Compile Include="HttpServer\LoggerUtils.cs" />
     <Compile Include="HttpServer\RangeRequestWriter.cs" />
     <Compile Include="HttpServer\ResponseFilter.cs" />
@@ -263,6 +264,9 @@
       <Project>{442b5058-dcaf-4263-bb6a-f21e31120a1b}</Project>
       <Name>MediaBrowser.Providers</Name>
     </ProjectReference>
+    <Reference Include="ServiceStack">
+      <HintPath>..\ThirdParty\ServiceStack\ServiceStack.dll</HintPath>
+    </Reference>
     <Reference Include="SocketHttpListener.Portable">
       <HintPath>..\ThirdParty\emby\SocketHttpListener.Portable.dll</HintPath>
     </Reference>
diff --git a/Emby.Server.Implementations/HttpServer/HttpResultFactory.cs b/Emby.Server.Implementations/HttpServer/HttpResultFactory.cs
new file mode 100644
index 000000000..bbd556661
--- /dev/null
+++ b/Emby.Server.Implementations/HttpServer/HttpResultFactory.cs
@@ -0,0 +1,847 @@
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.Net;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.IO.Compression;
+using System.Net;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml;
+using Emby.Server.Implementations.HttpServer;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Services;
+using ServiceStack;
+using ServiceStack.Host;
+using IRequest = MediaBrowser.Model.Services.IRequest;
+using MimeTypes = MediaBrowser.Model.Net.MimeTypes;
+using StreamWriter = Emby.Server.Implementations.HttpServer.StreamWriter;
+
+namespace Emby.Server.Implementations.HttpServer
+{
+    /// <summary>
+    /// Class HttpResultFactory
+    /// </summary>
+    public class HttpResultFactory : IHttpResultFactory
+    {
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+        private readonly IFileSystem _fileSystem;
+        private readonly IJsonSerializer _jsonSerializer;
+        private readonly IXmlSerializer _xmlSerializer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HttpResultFactory" /> class.
+        /// </summary>
+        /// <param name="logManager">The log manager.</param>
+        /// <param name="fileSystem">The file system.</param>
+        /// <param name="jsonSerializer">The json serializer.</param>
+        public HttpResultFactory(ILogManager logManager, IFileSystem fileSystem, IJsonSerializer jsonSerializer, IXmlSerializer xmlSerializer)
+        {
+            _fileSystem = fileSystem;
+            _jsonSerializer = jsonSerializer;
+            _xmlSerializer = xmlSerializer;
+            _logger = logManager.GetLogger("HttpResultFactory");
+        }
+
+        /// <summary>
+        /// Gets the result.
+        /// </summary>
+        /// <param name="content">The content.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        public object GetResult(object content, string contentType, IDictionary<string, string> responseHeaders = null)
+        {
+            return GetHttpResult(content, contentType, responseHeaders);
+        }
+
+        /// <summary>
+        /// Gets the HTTP result.
+        /// </summary>
+        /// <param name="content">The content.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>IHasHeaders.</returns>
+        private IHasHeaders GetHttpResult(object content, string contentType, IDictionary<string, string> responseHeaders = null)
+        {
+            IHasHeaders result;
+
+            var stream = content as Stream;
+
+            if (stream != null)
+            {
+                result = new StreamWriter(stream, contentType, _logger);
+            }
+
+            else
+            {
+                var bytes = content as byte[];
+
+                if (bytes != null)
+                {
+                    result = new StreamWriter(bytes, contentType, _logger);
+                }
+                else
+                {
+                    var text = content as string;
+
+                    if (text != null)
+                    {
+                        result = new StreamWriter(Encoding.UTF8.GetBytes(text), contentType, _logger);
+                    }
+                    else
+                    {
+                        result = new HttpResult(content, contentType);
+                    }
+                }
+            }
+            if (responseHeaders == null)
+            {
+                responseHeaders = new Dictionary<string, string>();
+            }
+
+            responseHeaders["Expires"] = "-1";
+            AddResponseHeaders(result, responseHeaders);
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets the optimized result.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="result">The result.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">result</exception>
+        public object GetOptimizedResult<T>(IRequest requestContext, T result, IDictionary<string, string> responseHeaders = null)
+            where T : class
+        {
+            return GetOptimizedResultInternal<T>(requestContext, result, true, responseHeaders);
+        }
+
+        private object GetOptimizedResultInternal<T>(IRequest requestContext, T result, bool addCachePrevention, IDictionary<string, string> responseHeaders = null)
+          where T : class
+        {
+            if (result == null)
+            {
+                throw new ArgumentNullException("result");
+            }
+
+            var optimizedResult = ToOptimizedResult(requestContext, result);
+
+            if (responseHeaders == null)
+            {
+                responseHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            }
+
+            if (addCachePrevention)
+            {
+                responseHeaders["Expires"] = "-1";
+            }
+
+            // Apply headers
+            var hasHeaders = optimizedResult as IHasHeaders;
+
+            if (hasHeaders != null)
+            {
+                AddResponseHeaders(hasHeaders, responseHeaders);
+            }
+
+            return optimizedResult;
+        }
+
+        public static string GetCompressionType(IRequest request)
+        {
+            var acceptEncoding = request.Headers["Accept-Encoding"];
+
+            if (!string.IsNullOrWhiteSpace(acceptEncoding))
+            {
+                if (acceptEncoding.Contains("deflate"))
+                    return "deflate";
+
+                if (acceptEncoding.Contains("gzip"))
+                    return "gzip";
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Returns the optimized result for the IRequestContext. 
+        /// Does not use or store results in any cache.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="dto"></param>
+        /// <returns></returns>
+        public object ToOptimizedResult<T>(IRequest request, T dto)
+        {
+            request.Response.Dto = dto;
+
+            var compressionType = GetCompressionType(request);
+            if (compressionType == null)
+            {
+                var contentType = request.ResponseContentType;
+
+                switch (GetRealContentType(contentType))
+                {
+                    case "application/xml":
+                    case "text/xml":
+                    case "text/xml; charset=utf-8": //"text/xml; charset=utf-8" also matches xml
+                        return SerializeToXmlString(dto);
+
+                    case "application/json":
+                    case "text/json":
+                        return _jsonSerializer.SerializeToString(dto);
+                }
+            }
+
+            using (var ms = new MemoryStream())
+            {
+                using (var compressionStream = GetCompressionStream(ms, compressionType))
+                {
+                    ContentTypes.Instance.SerializeToStream(request, dto, compressionStream);
+                    compressionStream.Dispose();
+
+                    var compressedBytes = ms.ToArray();
+
+                    var httpResult = new HttpResult(compressedBytes, request.ResponseContentType)
+                    {
+                        Status = request.Response.StatusCode
+                    };
+
+                    httpResult.Headers["Content-Length"] = compressedBytes.Length.ToString(UsCulture);
+                    httpResult.Headers["Content-Encoding"] = compressionType;
+
+                    return httpResult;
+                }
+            }
+        }
+
+        public static string GetRealContentType(string contentType)
+        {
+            return contentType == null
+                       ? null
+                       : contentType.Split(';')[0].ToLower().Trim();
+        }
+
+        public static string SerializeToXmlString(object from)
+        {
+            using (var ms = new MemoryStream())
+            {
+                var xwSettings = new XmlWriterSettings();
+                xwSettings.Encoding = new UTF8Encoding(false);
+                xwSettings.OmitXmlDeclaration = false;
+
+                using (var xw = XmlWriter.Create(ms, xwSettings))
+                {
+                    var serializer = new DataContractSerializer(from.GetType());
+                    serializer.WriteObject(xw, from);
+                    xw.Flush();
+                    ms.Seek(0, SeekOrigin.Begin);
+                    var reader = new StreamReader(ms);
+                    return reader.ReadToEnd();
+                }
+            }
+        }
+
+        private static Stream GetCompressionStream(Stream outputStream, string compressionType)
+        {
+            if (compressionType == "deflate")
+                return new DeflateStream(outputStream, CompressionMode.Compress);
+            if (compressionType == "gzip")
+                return new GZipStream(outputStream, CompressionMode.Compress);
+
+            throw new NotSupportedException(compressionType);
+        }
+
+        /// <summary>
+        /// Gets the optimized result using cache.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="factoryFn">The factory fn.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">cacheKey
+        /// or
+        /// factoryFn</exception>
+        public object GetOptimizedResultUsingCache<T>(IRequest requestContext, Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, IDictionary<string, string> responseHeaders = null)
+               where T : class
+        {
+            if (cacheKey == Guid.Empty)
+            {
+                throw new ArgumentNullException("cacheKey");
+            }
+            if (factoryFn == null)
+            {
+                throw new ArgumentNullException("factoryFn");
+            }
+
+            var key = cacheKey.ToString("N");
+
+            if (responseHeaders == null)
+            {
+                responseHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            }
+
+            // See if the result is already cached in the browser
+            var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, null);
+
+            if (result != null)
+            {
+                return result;
+            }
+
+            return GetOptimizedResultInternal(requestContext, factoryFn(), false, responseHeaders);
+        }
+
+        /// <summary>
+        /// To the cached result.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="factoryFn">The factory fn.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        /// <returns>System.Object.</returns>
+        /// <exception cref="System.ArgumentNullException">cacheKey</exception>
+        public object GetCachedResult<T>(IRequest requestContext, Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, string contentType, IDictionary<string, string> responseHeaders = null)
+          where T : class
+        {
+            if (cacheKey == Guid.Empty)
+            {
+                throw new ArgumentNullException("cacheKey");
+            }
+            if (factoryFn == null)
+            {
+                throw new ArgumentNullException("factoryFn");
+            }
+
+            var key = cacheKey.ToString("N");
+
+            if (responseHeaders == null)
+            {
+                responseHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            }
+
+            // See if the result is already cached in the browser
+            var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, contentType);
+
+            if (result != null)
+            {
+                return result;
+            }
+
+            result = factoryFn();
+
+            // Apply caching headers
+            var hasHeaders = result as IHasHeaders;
+
+            if (hasHeaders != null)
+            {
+                AddResponseHeaders(hasHeaders, responseHeaders);
+                return hasHeaders;
+            }
+
+            IHasHeaders httpResult;
+
+            var stream = result as Stream;
+
+            if (stream != null)
+            {
+                httpResult = new StreamWriter(stream, contentType, _logger);
+            }
+            else
+            {
+                // Otherwise wrap into an HttpResult
+                httpResult = new HttpResult(result, contentType ?? "text/html", HttpStatusCode.NotModified);
+            }
+
+            AddResponseHeaders(httpResult, responseHeaders);
+
+            return httpResult;
+        }
+
+        /// <summary>
+        /// Pres the process optimized result.
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="responseHeaders">The responseHeaders.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="cacheKeyString">The cache key string.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <returns>System.Object.</returns>
+        private object GetCachedResult(IRequest requestContext, IDictionary<string, string> responseHeaders, Guid cacheKey, string cacheKeyString, DateTime? lastDateModified, TimeSpan? cacheDuration, string contentType)
+        {
+            responseHeaders["ETag"] = string.Format("\"{0}\"", cacheKeyString);
+
+            if (IsNotModified(requestContext, cacheKey, lastDateModified, cacheDuration))
+            {
+                AddAgeHeader(responseHeaders, lastDateModified);
+                AddExpiresHeader(responseHeaders, cacheKeyString, cacheDuration);
+
+                var result = new HttpResult(new byte[] { }, contentType ?? "text/html", HttpStatusCode.NotModified);
+
+                AddResponseHeaders(result, responseHeaders);
+
+                return result;
+            }
+
+            AddCachingHeaders(responseHeaders, cacheKeyString, lastDateModified, cacheDuration);
+
+            return null;
+        }
+
+        public Task<object> GetStaticFileResult(IRequest requestContext,
+            string path,
+            FileShareMode fileShare = FileShareMode.Read)
+        {
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            return GetStaticFileResult(requestContext, new StaticFileResultOptions
+            {
+                Path = path,
+                FileShare = fileShare
+            });
+        }
+
+        public Task<object> GetStaticFileResult(IRequest requestContext,
+            StaticFileResultOptions options)
+        {
+            var path = options.Path;
+            var fileShare = options.FileShare;
+
+            if (string.IsNullOrEmpty(path))
+            {
+                throw new ArgumentNullException("path");
+            }
+
+            if (fileShare != FileShareMode.Read && fileShare != FileShareMode.ReadWrite)
+            {
+                throw new ArgumentException("FileShare must be either Read or ReadWrite");
+            }
+
+            if (string.IsNullOrWhiteSpace(options.ContentType))
+            {
+                options.ContentType = MimeTypes.GetMimeType(path);
+            }
+
+            if (!options.DateLastModified.HasValue)
+            {
+                options.DateLastModified = _fileSystem.GetLastWriteTimeUtc(path);
+            }
+
+            var cacheKey = path + options.DateLastModified.Value.Ticks;
+
+            options.CacheKey = cacheKey.GetMD5();
+            options.ContentFactory = () => Task.FromResult(GetFileStream(path, fileShare));
+
+            return GetStaticResult(requestContext, options);
+        }
+
+        /// <summary>
+        /// Gets the file stream.
+        /// </summary>
+        /// <param name="path">The path.</param>
+        /// <param name="fileShare">The file share.</param>
+        /// <returns>Stream.</returns>
+        private Stream GetFileStream(string path, FileShareMode fileShare)
+        {
+            return _fileSystem.GetFileStream(path, FileOpenMode.Open, FileAccessMode.Read, fileShare);
+        }
+
+        public Task<object> GetStaticResult(IRequest requestContext,
+            Guid cacheKey,
+            DateTime? lastDateModified,
+            TimeSpan? cacheDuration,
+            string contentType,
+            Func<Task<Stream>> factoryFn,
+            IDictionary<string, string> responseHeaders = null,
+            bool isHeadRequest = false)
+        {
+            return GetStaticResult(requestContext, new StaticResultOptions
+            {
+                CacheDuration = cacheDuration,
+                CacheKey = cacheKey,
+                ContentFactory = factoryFn,
+                ContentType = contentType,
+                DateLastModified = lastDateModified,
+                IsHeadRequest = isHeadRequest,
+                ResponseHeaders = responseHeaders
+            });
+        }
+
+        public async Task<object> GetStaticResult(IRequest requestContext, StaticResultOptions options)
+        {
+            var cacheKey = options.CacheKey;
+            options.ResponseHeaders = options.ResponseHeaders ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            var contentType = options.ContentType;
+
+            if (cacheKey == Guid.Empty)
+            {
+                throw new ArgumentNullException("cacheKey");
+            }
+            if (options.ContentFactory == null)
+            {
+                throw new ArgumentNullException("factoryFn");
+            }
+
+            var key = cacheKey.ToString("N");
+
+            // See if the result is already cached in the browser
+            var result = GetCachedResult(requestContext, options.ResponseHeaders, cacheKey, key, options.DateLastModified, options.CacheDuration, contentType);
+
+            if (result != null)
+            {
+                return result;
+            }
+
+            var compress = ShouldCompressResponse(requestContext, contentType);
+            var hasHeaders = await GetStaticResult(requestContext, options, compress).ConfigureAwait(false);
+            AddResponseHeaders(hasHeaders, options.ResponseHeaders);
+
+            return hasHeaders;
+        }
+
+        /// <summary>
+        /// Shoulds the compress response.
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="contentType">Type of the content.</param>
+        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
+        private bool ShouldCompressResponse(IRequest requestContext, string contentType)
+        {
+            // It will take some work to support compression with byte range requests
+            if (!string.IsNullOrEmpty(requestContext.Headers.Get("Range")))
+            {
+                return false;
+            }
+
+            // Don't compress media
+            if (contentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase) || contentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            // Don't compress images
+            if (contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+
+            if (contentType.StartsWith("font/", StringComparison.OrdinalIgnoreCase))
+            {
+                return false;
+            }
+            if (contentType.StartsWith("application/", StringComparison.OrdinalIgnoreCase))
+            {
+                if (string.Equals(contentType, "application/x-javascript", StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+                if (string.Equals(contentType, "application/xml", StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// The us culture
+        /// </summary>
+        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
+
+        private async Task<IHasHeaders> GetStaticResult(IRequest requestContext, StaticResultOptions options, bool compress)
+        {
+            var isHeadRequest = options.IsHeadRequest;
+            var factoryFn = options.ContentFactory;
+            var contentType = options.ContentType;
+            var responseHeaders = options.ResponseHeaders;
+
+            var requestedCompressionType = GetCompressionType(requestContext);
+
+            if (!compress || string.IsNullOrEmpty(requestedCompressionType))
+            {
+                var rangeHeader = requestContext.Headers.Get("Range");
+
+                var stream = await factoryFn().ConfigureAwait(false);
+
+                if (!string.IsNullOrEmpty(rangeHeader))
+                {
+                    return new RangeRequestWriter(rangeHeader, stream, contentType, isHeadRequest, _logger)
+                    {
+                        OnComplete = options.OnComplete
+                    };
+                }
+
+                responseHeaders["Content-Length"] = stream.Length.ToString(UsCulture);
+
+                if (isHeadRequest)
+                {
+                    stream.Dispose();
+
+                    return GetHttpResult(new byte[] { }, contentType);
+                }
+
+                return new StreamWriter(stream, contentType, _logger)
+                {
+                    OnComplete = options.OnComplete,
+                    OnError = options.OnError
+                };
+            }
+
+            string content;
+
+            using (var stream = await factoryFn().ConfigureAwait(false))
+            {
+                using (var reader = new StreamReader(stream))
+                {
+                    content = await reader.ReadToEndAsync().ConfigureAwait(false);
+                }
+            }
+
+            var contents = Compress(content, requestedCompressionType);
+
+            responseHeaders["Content-Length"] = contents.Length.ToString(UsCulture);
+            responseHeaders["Content-Encoding"] = requestedCompressionType;
+
+            if (isHeadRequest)
+            {
+                return GetHttpResult(new byte[] { }, contentType);
+            }
+
+            return GetHttpResult(contents, contentType, responseHeaders);
+        }
+
+        public static byte[] Compress(string text, string compressionType)
+        {
+            if (compressionType == "deflate")
+                return Deflate(text);
+
+            if (compressionType == "gzip")
+                return GZip(text);
+
+            throw new NotSupportedException(compressionType);
+        }
+
+        public static byte[] Deflate(string text)
+        {
+            return Deflate(Encoding.UTF8.GetBytes(text));
+        }
+
+        public static byte[] Deflate(byte[] bytes)
+        {
+            // In .NET FX incompat-ville, you can't access compressed bytes without closing DeflateStream
+            // Which means we must use MemoryStream since you have to use ToArray() on a closed Stream
+            using (var ms = new MemoryStream())
+            using (var zipStream = new DeflateStream(ms, CompressionMode.Compress))
+            {
+                zipStream.Write(bytes, 0, bytes.Length);
+                zipStream.Dispose();
+
+                return ms.ToArray();
+            }
+        }
+
+        public static byte[] GZip(string text)
+        {
+            return GZip(Encoding.UTF8.GetBytes(text));
+        }
+
+        public static byte[] GZip(byte[] buffer)
+        {
+            using (var ms = new MemoryStream())
+            using (var zipStream = new GZipStream(ms, CompressionMode.Compress))
+            {
+                zipStream.Write(buffer, 0, buffer.Length);
+                zipStream.Dispose();
+
+                return ms.ToArray();
+            }
+        }
+
+        /// <summary>
+        /// Adds the caching responseHeaders.
+        /// </summary>
+        /// <param name="responseHeaders">The responseHeaders.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        private void AddCachingHeaders(IDictionary<string, string> responseHeaders, string cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
+        {
+            // Don't specify both last modified and Etag, unless caching unconditionally. They are redundant
+            // https://developers.google.com/speed/docs/best-practices/caching#LeverageBrowserCaching
+            if (lastDateModified.HasValue && (string.IsNullOrEmpty(cacheKey) || cacheDuration.HasValue))
+            {
+                AddAgeHeader(responseHeaders, lastDateModified);
+                responseHeaders["Last-Modified"] = lastDateModified.Value.ToString("r");
+            }
+
+            if (cacheDuration.HasValue)
+            {
+                responseHeaders["Cache-Control"] = "public, max-age=" + Convert.ToInt32(cacheDuration.Value.TotalSeconds);
+            }
+            else if (!string.IsNullOrEmpty(cacheKey))
+            {
+                responseHeaders["Cache-Control"] = "public";
+            }
+            else
+            {
+                responseHeaders["Cache-Control"] = "no-cache, no-store, must-revalidate";
+                responseHeaders["pragma"] = "no-cache, no-store, must-revalidate";
+            }
+
+            AddExpiresHeader(responseHeaders, cacheKey, cacheDuration);
+        }
+
+        /// <summary>
+        /// Adds the expires header.
+        /// </summary>
+        /// <param name="responseHeaders">The responseHeaders.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        private void AddExpiresHeader(IDictionary<string, string> responseHeaders, string cacheKey, TimeSpan? cacheDuration)
+        {
+            if (cacheDuration.HasValue)
+            {
+                responseHeaders["Expires"] = DateTime.UtcNow.Add(cacheDuration.Value).ToString("r");
+            }
+            else if (string.IsNullOrEmpty(cacheKey))
+            {
+                responseHeaders["Expires"] = "-1";
+            }
+        }
+
+        /// <summary>
+        /// Adds the age header.
+        /// </summary>
+        /// <param name="responseHeaders">The responseHeaders.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        private void AddAgeHeader(IDictionary<string, string> responseHeaders, DateTime? lastDateModified)
+        {
+            if (lastDateModified.HasValue)
+            {
+                responseHeaders["Age"] = Convert.ToInt64((DateTime.UtcNow - lastDateModified.Value).TotalSeconds).ToString(CultureInfo.InvariantCulture);
+            }
+        }
+        /// <summary>
+        /// Determines whether [is not modified] [the specified cache key].
+        /// </summary>
+        /// <param name="requestContext">The request context.</param>
+        /// <param name="cacheKey">The cache key.</param>
+        /// <param name="lastDateModified">The last date modified.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <returns><c>true</c> if [is not modified] [the specified cache key]; otherwise, <c>false</c>.</returns>
+        private bool IsNotModified(IRequest requestContext, Guid? cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
+        {
+            var isNotModified = true;
+
+            var ifModifiedSinceHeader = requestContext.Headers.Get("If-Modified-Since");
+
+            if (!string.IsNullOrEmpty(ifModifiedSinceHeader))
+            {
+                DateTime ifModifiedSince;
+
+                if (DateTime.TryParse(ifModifiedSinceHeader, out ifModifiedSince))
+                {
+                    isNotModified = IsNotModified(ifModifiedSince.ToUniversalTime(), cacheDuration, lastDateModified);
+                }
+            }
+
+            var ifNoneMatchHeader = requestContext.Headers.Get("If-None-Match");
+
+            // Validate If-None-Match
+            if (isNotModified && (cacheKey.HasValue || !string.IsNullOrEmpty(ifNoneMatchHeader)))
+            {
+                Guid ifNoneMatch;
+
+                if (Guid.TryParse(ifNoneMatchHeader ?? string.Empty, out ifNoneMatch))
+                {
+                    if (cacheKey.HasValue && cacheKey.Value == ifNoneMatch)
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Determines whether [is not modified] [the specified if modified since].
+        /// </summary>
+        /// <param name="ifModifiedSince">If modified since.</param>
+        /// <param name="cacheDuration">Duration of the cache.</param>
+        /// <param name="dateModified">The date modified.</param>
+        /// <returns><c>true</c> if [is not modified] [the specified if modified since]; otherwise, <c>false</c>.</returns>
+        private bool IsNotModified(DateTime ifModifiedSince, TimeSpan? cacheDuration, DateTime? dateModified)
+        {
+            if (dateModified.HasValue)
+            {
+                var lastModified = NormalizeDateForComparison(dateModified.Value);
+                ifModifiedSince = NormalizeDateForComparison(ifModifiedSince);
+
+                return lastModified <= ifModifiedSince;
+            }
+
+            if (cacheDuration.HasValue)
+            {
+                var cacheExpirationDate = ifModifiedSince.Add(cacheDuration.Value);
+
+                if (DateTime.UtcNow < cacheExpirationDate)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+
+        /// <summary>
+        /// When the browser sends the IfModifiedDate, it's precision is limited to seconds, so this will account for that
+        /// </summary>
+        /// <param name="date">The date.</param>
+        /// <returns>DateTime.</returns>
+        private DateTime NormalizeDateForComparison(DateTime date)
+        {
+            return new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Kind);
+        }
+
+        /// <summary>
+        /// Adds the response headers.
+        /// </summary>
+        /// <param name="hasHeaders">The has options.</param>
+        /// <param name="responseHeaders">The response headers.</param>
+        private void AddResponseHeaders(IHasHeaders hasHeaders, IEnumerable<KeyValuePair<string, string>> responseHeaders)
+        {
+            foreach (var item in responseHeaders)
+            {
+                hasHeaders.Headers[item.Key] = item.Value;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
index 813f07fff..c32af8eb1 100644
--- a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
@@ -127,23 +127,7 @@ namespace Emby.Server.Implementations.Library.Validators
                 {
                     var item = _libraryManager.GetPerson(person.Key);
 
-                    var hasMetdata = !string.IsNullOrWhiteSpace(item.Overview);
-                    var performFullRefresh = !hasMetdata && (DateTime.UtcNow - item.DateLastRefreshed).TotalDays >= 30;
-
-                    var defaultMetadataRefreshMode = performFullRefresh
-                        ? MetadataRefreshMode.FullRefresh
-                        : MetadataRefreshMode.Default;
-
-                    var imageRefreshMode = performFullRefresh
-                        ? ImageRefreshMode.FullRefresh
-                        : ImageRefreshMode.Default;
-
-                    var options = new MetadataRefreshOptions(_fileSystem)
-                    {
-                        MetadataRefreshMode = person.Value ? defaultMetadataRefreshMode : MetadataRefreshMode.ValidationOnly,
-                        ImageRefreshMode = person.Value ? imageRefreshMode : ImageRefreshMode.ValidationOnly,
-                        ForceSave = performFullRefresh
-                    };
+                    var options = new MetadataRefreshOptions(_fileSystem);
 
                     await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
                 }
diff --git a/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs b/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs
index 643d0c956..4218370ac 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/HttpListenerHost.cs
@@ -28,6 +28,7 @@ using MediaBrowser.Model.Net;
 using MediaBrowser.Model.Serialization;
 using MediaBrowser.Model.Services;
 using MediaBrowser.Model.Text;
+using ServiceStack.Text.Jsv;
 using SocketHttpListener.Net;
 using SocketHttpListener.Primitives;
 
@@ -87,9 +88,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer
 
         public override void Configure()
         {
-            HostConfig.Instance.DefaultRedirectPath = DefaultRedirectPath;
-
-            HostConfig.Instance.MapExceptionToStatusCode = new Dictionary<Type, int>
+            var mapExceptionToStatusCode = new Dictionary<Type, int>
             {
                 {typeof (InvalidOperationException), 500},
                 {typeof (NotImplementedException), 500},
@@ -126,21 +125,24 @@ namespace MediaBrowser.Server.Implementations.HttpServer
             return _appHost.Resolve<T>();
         }
 
-        public override T TryResolve<T>()
+        public override Type[] GetGenericArguments(Type type)
         {
-            return _appHost.TryResolve<T>();
+            return type.GetGenericArguments();
         }
 
-        public override object CreateInstance(Type type)
+        public override bool IsAssignableFrom(Type type1, Type type2)
         {
-            return _appHost.CreateInstance(type);
+            return type1.IsAssignableFrom(type2);
         }
 
-        public override void OnConfigLoad()
+        public override T TryResolve<T>()
         {
-            base.OnConfigLoad();
+            return _appHost.TryResolve<T>();
+        }
 
-            Config.HandlerFactoryPath = null;
+        public override object CreateInstance(Type type)
+        {
+            return _appHost.CreateInstance(type);
         }
 
         protected override ServiceController CreateServiceController(params Assembly[] assembliesWithServices)
@@ -156,12 +158,14 @@ namespace MediaBrowser.Server.Implementations.HttpServer
             return this;
         }
 
+        public static string HandlerFactoryPath;
+
         /// <summary>
         /// Starts the Web Service
         /// </summary>
         private void StartListener()
         {
-            HostContext.Config.HandlerFactoryPath = GetHandlerPathIfAny(UrlPrefixes.First());
+            HandlerFactoryPath = GetHandlerPathIfAny(UrlPrefixes.First());
 
             _listener = GetListener();
 
@@ -610,6 +614,40 @@ namespace MediaBrowser.Server.Implementations.HttpServer
             return routes.ToArray();
         }
 
+        public override object GetTaskResult(Task task, string requestName)
+        {
+            try
+            {
+                var taskObject = task as Task<object>;
+                if (taskObject != null)
+                {
+                    return taskObject.Result;
+                }
+
+                task.Wait();
+
+                var type = task.GetType();
+                if (!type.IsGenericType)
+                {
+                    return null;
+                }
+
+                Logger.Warn("Getting task result from " + requestName + " using reflection. For better performance have your api return Task<object>");
+                return type.GetProperty("Result").GetValue(task);
+            }
+            catch (TypeAccessException)
+            {
+                return null; //return null for void Task's
+            }
+        }
+
+        public override Func<string, object> GetParseFn(Type propertyType)
+        {
+            var fn = JsvReader.GetParseFn(propertyType);
+
+            return s => fn(s);
+        }
+
         public override void SerializeToJson(object o, Stream stream)
         {
             _jsonSerializer.SerializeToStream(o, stream);
diff --git a/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs b/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
deleted file mode 100644
index b013a0952..000000000
--- a/MediaBrowser.Server.Implementations/HttpServer/HttpResultFactory.cs
+++ /dev/null
@@ -1,835 +0,0 @@
-using MediaBrowser.Common.Extensions;
-using MediaBrowser.Controller.Net;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Serialization;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.IO.Compression;
-using System.Net;
-using System.Runtime.Serialization;
-using System.Text;
-using System.Threading.Tasks;
-using System.Xml;
-using Emby.Server.Implementations.HttpServer;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Services;
-using ServiceStack;
-using ServiceStack.Host;
-using IRequest = MediaBrowser.Model.Services.IRequest;
-using MimeTypes = MediaBrowser.Model.Net.MimeTypes;
-using StreamWriter = Emby.Server.Implementations.HttpServer.StreamWriter;
-
-namespace MediaBrowser.Server.Implementations.HttpServer
-{
-    /// <summary>
-    /// Class HttpResultFactory
-    /// </summary>
-    public class HttpResultFactory : IHttpResultFactory
-    {
-        /// <summary>
-        /// The _logger
-        /// </summary>
-        private readonly ILogger _logger;
-        private readonly IFileSystem _fileSystem;
-        private readonly IJsonSerializer _jsonSerializer;
-        private readonly IXmlSerializer _xmlSerializer;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="HttpResultFactory" /> class.
-        /// </summary>
-        /// <param name="logManager">The log manager.</param>
-        /// <param name="fileSystem">The file system.</param>
-        /// <param name="jsonSerializer">The json serializer.</param>
-        public HttpResultFactory(ILogManager logManager, IFileSystem fileSystem, IJsonSerializer jsonSerializer, IXmlSerializer xmlSerializer)
-        {
-            _fileSystem = fileSystem;
-            _jsonSerializer = jsonSerializer;
-            _xmlSerializer = xmlSerializer;
-            _logger = logManager.GetLogger("HttpResultFactory");
-        }
-
-        /// <summary>
-        /// Gets the result.
-        /// </summary>
-        /// <param name="content">The content.</param>
-        /// <param name="contentType">Type of the content.</param>
-        /// <param name="responseHeaders">The response headers.</param>
-        /// <returns>System.Object.</returns>
-        public object GetResult(object content, string contentType, IDictionary<string, string> responseHeaders = null)
-        {
-            return GetHttpResult(content, contentType, responseHeaders);
-        }
-
-        /// <summary>
-        /// Gets the HTTP result.
-        /// </summary>
-        /// <param name="content">The content.</param>
-        /// <param name="contentType">Type of the content.</param>
-        /// <param name="responseHeaders">The response headers.</param>
-        /// <returns>IHasHeaders.</returns>
-        private IHasHeaders GetHttpResult(object content, string contentType, IDictionary<string, string> responseHeaders = null)
-        {
-            IHasHeaders result;
-
-            var stream = content as Stream;
-
-            if (stream != null)
-            {
-                result = new StreamWriter(stream, contentType, _logger);
-            }
-
-            else
-            {
-                var bytes = content as byte[];
-
-                if (bytes != null)
-                {
-                    result = new StreamWriter(bytes, contentType, _logger);
-                }
-                else
-                {
-                    var text = content as string;
-
-                    if (text != null)
-                    {
-                        result = new StreamWriter(Encoding.UTF8.GetBytes(text), contentType, _logger);
-                    }
-                    else
-                    {
-                        result = new HttpResult(content, contentType);
-                    }
-                }
-            }
-            if (responseHeaders == null)
-            {
-                responseHeaders = new Dictionary<string, string>();
-            }
-
-            responseHeaders["Expires"] = "-1";
-            AddResponseHeaders(result, responseHeaders);
-
-            return result;
-        }
-
-        /// <summary>
-        /// Gets the optimized result.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="requestContext">The request context.</param>
-        /// <param name="result">The result.</param>
-        /// <param name="responseHeaders">The response headers.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">result</exception>
-        public object GetOptimizedResult<T>(IRequest requestContext, T result, IDictionary<string, string> responseHeaders = null)
-            where T : class
-        {
-            return GetOptimizedResultInternal<T>(requestContext, result, true, responseHeaders);
-        }
-
-        private object GetOptimizedResultInternal<T>(IRequest requestContext, T result, bool addCachePrevention, IDictionary<string, string> responseHeaders = null)
-          where T : class
-        {
-            if (result == null)
-            {
-                throw new ArgumentNullException("result");
-            }
-
-            var optimizedResult = ToOptimizedResult(requestContext, result);
-
-            if (responseHeaders == null)
-            {
-                responseHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-            }
-
-            if (addCachePrevention)
-            {
-                responseHeaders["Expires"] = "-1";
-            }
-
-            // Apply headers
-            var hasHeaders = optimizedResult as IHasHeaders;
-
-            if (hasHeaders != null)
-            {
-                AddResponseHeaders(hasHeaders, responseHeaders);
-            }
-
-            return optimizedResult;
-        }
-
-        public static string GetCompressionType(IRequest request)
-        {
-            var prefs = new RequestPreferences(request);
-
-            if (prefs.AcceptsDeflate)
-                return "deflate";
-
-            if (prefs.AcceptsGzip)
-                return "gzip";
-
-            return null;
-        }
-
-        /// <summary>
-        /// Returns the optimized result for the IRequestContext. 
-        /// Does not use or store results in any cache.
-        /// </summary>
-        /// <param name="request"></param>
-        /// <param name="dto"></param>
-        /// <returns></returns>
-        public object ToOptimizedResult<T>(IRequest request, T dto)
-        {
-            request.Response.Dto = dto;
-
-            var compressionType = GetCompressionType(request);
-            if (compressionType == null)
-            {
-                var contentType = request.ResponseContentType;
-                var contentTypeAttr = ContentFormat.GetEndpointAttributes(contentType);
-
-                switch (contentTypeAttr)
-                {
-                    case RequestAttributes.Xml:
-                        return SerializeToXmlString(dto);
-
-                    case RequestAttributes.Json:
-                        return _jsonSerializer.SerializeToString(dto);
-                }
-            }
-
-            using (var ms = new MemoryStream())
-            {
-                using (var compressionStream = GetCompressionStream(ms, compressionType))
-                {
-                    ContentTypes.Instance.SerializeToStream(request, dto, compressionStream);
-                    compressionStream.Close();
-
-                    var compressedBytes = ms.ToArray();
-
-                    var httpResult = new HttpResult(compressedBytes, request.ResponseContentType)
-                    {
-                        Status = request.Response.StatusCode
-                    };
-
-                    httpResult.Headers["Content-Length"] = compressedBytes.Length.ToString(UsCulture);
-                    httpResult.Headers["Content-Encoding"] = compressionType;
-
-                    return httpResult;
-                }
-            }
-        }
-
-        public static string SerializeToXmlString(object from)
-        {
-            using (var ms = new MemoryStream())
-            {
-                var xwSettings = new XmlWriterSettings();
-                xwSettings.Encoding = new UTF8Encoding(false);
-                xwSettings.OmitXmlDeclaration = false;
-
-                using (var xw = XmlWriter.Create(ms, xwSettings))
-                {
-                    var serializer = new DataContractSerializer(from.GetType());
-                    serializer.WriteObject(xw, from);
-                    xw.Flush();
-                    ms.Seek(0, SeekOrigin.Begin);
-                    var reader = new StreamReader(ms);
-                    return reader.ReadToEnd();
-                }
-            }
-        }
-
-        private static Stream GetCompressionStream(Stream outputStream, string compressionType)
-        {
-            if (compressionType == "deflate")
-                return new DeflateStream(outputStream, CompressionMode.Compress);
-            if (compressionType == "gzip")
-                return new GZipStream(outputStream, CompressionMode.Compress);
-
-            throw new NotSupportedException(compressionType);
-        }
-
-        /// <summary>
-        /// Gets the optimized result using cache.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="requestContext">The request context.</param>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <param name="factoryFn">The factory fn.</param>
-        /// <param name="responseHeaders">The response headers.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">cacheKey
-        /// or
-        /// factoryFn</exception>
-        public object GetOptimizedResultUsingCache<T>(IRequest requestContext, Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, IDictionary<string, string> responseHeaders = null)
-               where T : class
-        {
-            if (cacheKey == Guid.Empty)
-            {
-                throw new ArgumentNullException("cacheKey");
-            }
-            if (factoryFn == null)
-            {
-                throw new ArgumentNullException("factoryFn");
-            }
-
-            var key = cacheKey.ToString("N");
-
-            if (responseHeaders == null)
-            {
-                responseHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-            }
-
-            // See if the result is already cached in the browser
-            var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, null);
-
-            if (result != null)
-            {
-                return result;
-            }
-
-            return GetOptimizedResultInternal(requestContext, factoryFn(), false, responseHeaders);
-        }
-
-        /// <summary>
-        /// To the cached result.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="requestContext">The request context.</param>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <param name="factoryFn">The factory fn.</param>
-        /// <param name="contentType">Type of the content.</param>
-        /// <param name="responseHeaders">The response headers.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">cacheKey</exception>
-        public object GetCachedResult<T>(IRequest requestContext, Guid cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration, Func<T> factoryFn, string contentType, IDictionary<string, string> responseHeaders = null)
-          where T : class
-        {
-            if (cacheKey == Guid.Empty)
-            {
-                throw new ArgumentNullException("cacheKey");
-            }
-            if (factoryFn == null)
-            {
-                throw new ArgumentNullException("factoryFn");
-            }
-
-            var key = cacheKey.ToString("N");
-
-            if (responseHeaders == null)
-            {
-                responseHeaders = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-            }
-
-            // See if the result is already cached in the browser
-            var result = GetCachedResult(requestContext, responseHeaders, cacheKey, key, lastDateModified, cacheDuration, contentType);
-
-            if (result != null)
-            {
-                return result;
-            }
-
-            result = factoryFn();
-
-            // Apply caching headers
-            var hasHeaders = result as IHasHeaders;
-
-            if (hasHeaders != null)
-            {
-                AddResponseHeaders(hasHeaders, responseHeaders);
-                return hasHeaders;
-            }
-
-            IHasHeaders httpResult;
-
-            var stream = result as Stream;
-
-            if (stream != null)
-            {
-                httpResult = new StreamWriter(stream, contentType, _logger);
-            }
-            else
-            {
-                // Otherwise wrap into an HttpResult
-                httpResult = new HttpResult(result, contentType ?? "text/html", HttpStatusCode.NotModified);
-            }
-
-            AddResponseHeaders(httpResult, responseHeaders);
-
-            return httpResult;
-        }
-
-        /// <summary>
-        /// Pres the process optimized result.
-        /// </summary>
-        /// <param name="requestContext">The request context.</param>
-        /// <param name="responseHeaders">The responseHeaders.</param>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="cacheKeyString">The cache key string.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <param name="contentType">Type of the content.</param>
-        /// <returns>System.Object.</returns>
-        private object GetCachedResult(IRequest requestContext, IDictionary<string, string> responseHeaders, Guid cacheKey, string cacheKeyString, DateTime? lastDateModified, TimeSpan? cacheDuration, string contentType)
-        {
-            responseHeaders["ETag"] = string.Format("\"{0}\"", cacheKeyString);
-
-            if (IsNotModified(requestContext, cacheKey, lastDateModified, cacheDuration))
-            {
-                AddAgeHeader(responseHeaders, lastDateModified);
-                AddExpiresHeader(responseHeaders, cacheKeyString, cacheDuration);
-
-                var result = new HttpResult(new byte[] { }, contentType ?? "text/html", HttpStatusCode.NotModified);
-
-                AddResponseHeaders(result, responseHeaders);
-
-                return result;
-            }
-
-            AddCachingHeaders(responseHeaders, cacheKeyString, lastDateModified, cacheDuration);
-
-            return null;
-        }
-
-        public Task<object> GetStaticFileResult(IRequest requestContext,
-            string path,
-            FileShareMode fileShare = FileShareMode.Read)
-        {
-            if (string.IsNullOrEmpty(path))
-            {
-                throw new ArgumentNullException("path");
-            }
-
-            return GetStaticFileResult(requestContext, new StaticFileResultOptions
-            {
-                Path = path,
-                FileShare = fileShare
-            });
-        }
-
-        public Task<object> GetStaticFileResult(IRequest requestContext,
-            StaticFileResultOptions options)
-        {
-            var path = options.Path;
-            var fileShare = options.FileShare;
-
-            if (string.IsNullOrEmpty(path))
-            {
-                throw new ArgumentNullException("path");
-            }
-
-            if (fileShare != FileShareMode.Read && fileShare != FileShareMode.ReadWrite)
-            {
-                throw new ArgumentException("FileShare must be either Read or ReadWrite");
-            }
-
-            if (string.IsNullOrWhiteSpace(options.ContentType))
-            {
-                options.ContentType = MimeTypes.GetMimeType(path);
-            }
-
-            if (!options.DateLastModified.HasValue)
-            {
-                options.DateLastModified = _fileSystem.GetLastWriteTimeUtc(path);
-            }
-
-            var cacheKey = path + options.DateLastModified.Value.Ticks;
-
-            options.CacheKey = cacheKey.GetMD5();
-            options.ContentFactory = () => Task.FromResult(GetFileStream(path, fileShare));
-
-            return GetStaticResult(requestContext, options);
-        }
-
-        /// <summary>
-        /// Gets the file stream.
-        /// </summary>
-        /// <param name="path">The path.</param>
-        /// <param name="fileShare">The file share.</param>
-        /// <returns>Stream.</returns>
-        private Stream GetFileStream(string path, FileShareMode fileShare)
-        {
-            return _fileSystem.GetFileStream(path, FileOpenMode.Open, FileAccessMode.Read, fileShare);
-        }
-
-        public Task<object> GetStaticResult(IRequest requestContext,
-            Guid cacheKey,
-            DateTime? lastDateModified,
-            TimeSpan? cacheDuration,
-            string contentType,
-            Func<Task<Stream>> factoryFn,
-            IDictionary<string, string> responseHeaders = null,
-            bool isHeadRequest = false)
-        {
-            return GetStaticResult(requestContext, new StaticResultOptions
-            {
-                CacheDuration = cacheDuration,
-                CacheKey = cacheKey,
-                ContentFactory = factoryFn,
-                ContentType = contentType,
-                DateLastModified = lastDateModified,
-                IsHeadRequest = isHeadRequest,
-                ResponseHeaders = responseHeaders
-            });
-        }
-
-        public async Task<object> GetStaticResult(IRequest requestContext, StaticResultOptions options)
-        {
-            var cacheKey = options.CacheKey;
-            options.ResponseHeaders = options.ResponseHeaders ?? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-            var contentType = options.ContentType;
-
-            if (cacheKey == Guid.Empty)
-            {
-                throw new ArgumentNullException("cacheKey");
-            }
-            if (options.ContentFactory == null)
-            {
-                throw new ArgumentNullException("factoryFn");
-            }
-
-            var key = cacheKey.ToString("N");
-
-            // See if the result is already cached in the browser
-            var result = GetCachedResult(requestContext, options.ResponseHeaders, cacheKey, key, options.DateLastModified, options.CacheDuration, contentType);
-
-            if (result != null)
-            {
-                return result;
-            }
-
-            var compress = ShouldCompressResponse(requestContext, contentType);
-            var hasHeaders = await GetStaticResult(requestContext, options, compress).ConfigureAwait(false);
-            AddResponseHeaders(hasHeaders, options.ResponseHeaders);
-
-            return hasHeaders;
-        }
-
-        /// <summary>
-        /// Shoulds the compress response.
-        /// </summary>
-        /// <param name="requestContext">The request context.</param>
-        /// <param name="contentType">Type of the content.</param>
-        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
-        private bool ShouldCompressResponse(IRequest requestContext, string contentType)
-        {
-            // It will take some work to support compression with byte range requests
-            if (!string.IsNullOrEmpty(requestContext.GetHeader("Range")))
-            {
-                return false;
-            }
-
-            // Don't compress media
-            if (contentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase) || contentType.StartsWith("video/", StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-
-            // Don't compress images
-            if (contentType.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-
-            if (contentType.StartsWith("font/", StringComparison.OrdinalIgnoreCase))
-            {
-                return false;
-            }
-            if (contentType.StartsWith("application/", StringComparison.OrdinalIgnoreCase))
-            {
-                if (string.Equals(contentType, "application/x-javascript", StringComparison.OrdinalIgnoreCase))
-                {
-                    return true;
-                }
-                if (string.Equals(contentType, "application/xml", StringComparison.OrdinalIgnoreCase))
-                {
-                    return true;
-                }
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// The us culture
-        /// </summary>
-        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
-
-        private async Task<IHasHeaders> GetStaticResult(IRequest requestContext, StaticResultOptions options, bool compress)
-        {
-            var isHeadRequest = options.IsHeadRequest;
-            var factoryFn = options.ContentFactory;
-            var contentType = options.ContentType;
-            var responseHeaders = options.ResponseHeaders;
-
-            var requestedCompressionType = GetCompressionType(requestContext);
-
-            if (!compress || string.IsNullOrEmpty(requestedCompressionType))
-            {
-                var rangeHeader = requestContext.GetHeader("Range");
-
-                var stream = await factoryFn().ConfigureAwait(false);
-
-                if (!string.IsNullOrEmpty(rangeHeader))
-                {
-                    return new RangeRequestWriter(rangeHeader, stream, contentType, isHeadRequest, _logger)
-                    {
-                        OnComplete = options.OnComplete
-                    };
-                }
-
-                responseHeaders["Content-Length"] = stream.Length.ToString(UsCulture);
-
-                if (isHeadRequest)
-                {
-                    stream.Dispose();
-
-                    return GetHttpResult(new byte[] { }, contentType);
-                }
-
-                return new StreamWriter(stream, contentType, _logger)
-                {
-                    OnComplete = options.OnComplete,
-                    OnError = options.OnError
-                };
-            }
-
-            string content;
-
-            using (var stream = await factoryFn().ConfigureAwait(false))
-            {
-                using (var reader = new StreamReader(stream))
-                {
-                    content = await reader.ReadToEndAsync().ConfigureAwait(false);
-                }
-            }
-
-            var contents = Compress(content, requestedCompressionType);
-
-            responseHeaders["Content-Length"] = contents.Length.ToString(UsCulture);
-            responseHeaders["Content-Encoding"] = requestedCompressionType;
-
-            if (isHeadRequest)
-            {
-                return GetHttpResult(new byte[] { }, contentType);
-            }
-
-            return GetHttpResult(contents, contentType, responseHeaders);
-        }
-
-        public static byte[] Compress(string text, string compressionType)
-        {
-            if (compressionType == "deflate")
-                return Deflate(text);
-
-            if (compressionType == "gzip")
-                return GZip(text);
-
-            throw new NotSupportedException(compressionType);
-        }
-
-        public static byte[] Deflate(string text)
-        {
-            return Deflate(Encoding.UTF8.GetBytes(text));
-        }
-
-        public static byte[] Deflate(byte[] bytes)
-        {
-            // In .NET FX incompat-ville, you can't access compressed bytes without closing DeflateStream
-            // Which means we must use MemoryStream since you have to use ToArray() on a closed Stream
-            using (var ms = new MemoryStream())
-            using (var zipStream = new DeflateStream(ms, CompressionMode.Compress))
-            {
-                zipStream.Write(bytes, 0, bytes.Length);
-                zipStream.Close();
-
-                return ms.ToArray();
-            }
-        }
-
-        public static byte[] GZip(string text)
-        {
-            return GZip(Encoding.UTF8.GetBytes(text));
-        }
-
-        public static byte[] GZip(byte[] buffer)
-        {
-            using (var ms = new MemoryStream())
-            using (var zipStream = new GZipStream(ms, CompressionMode.Compress))
-            {
-                zipStream.Write(buffer, 0, buffer.Length);
-                zipStream.Close();
-
-                return ms.ToArray();
-            }
-        }
-
-        /// <summary>
-        /// Adds the caching responseHeaders.
-        /// </summary>
-        /// <param name="responseHeaders">The responseHeaders.</param>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        private void AddCachingHeaders(IDictionary<string, string> responseHeaders, string cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
-        {
-            // Don't specify both last modified and Etag, unless caching unconditionally. They are redundant
-            // https://developers.google.com/speed/docs/best-practices/caching#LeverageBrowserCaching
-            if (lastDateModified.HasValue && (string.IsNullOrEmpty(cacheKey) || cacheDuration.HasValue))
-            {
-                AddAgeHeader(responseHeaders, lastDateModified);
-                responseHeaders["Last-Modified"] = lastDateModified.Value.ToString("r");
-            }
-
-            if (cacheDuration.HasValue)
-            {
-                responseHeaders["Cache-Control"] = "public, max-age=" + Convert.ToInt32(cacheDuration.Value.TotalSeconds);
-            }
-            else if (!string.IsNullOrEmpty(cacheKey))
-            {
-                responseHeaders["Cache-Control"] = "public";
-            }
-            else
-            {
-                responseHeaders["Cache-Control"] = "no-cache, no-store, must-revalidate";
-                responseHeaders["pragma"] = "no-cache, no-store, must-revalidate";
-            }
-
-            AddExpiresHeader(responseHeaders, cacheKey, cacheDuration);
-        }
-
-        /// <summary>
-        /// Adds the expires header.
-        /// </summary>
-        /// <param name="responseHeaders">The responseHeaders.</param>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        private void AddExpiresHeader(IDictionary<string, string> responseHeaders, string cacheKey, TimeSpan? cacheDuration)
-        {
-            if (cacheDuration.HasValue)
-            {
-                responseHeaders["Expires"] = DateTime.UtcNow.Add(cacheDuration.Value).ToString("r");
-            }
-            else if (string.IsNullOrEmpty(cacheKey))
-            {
-                responseHeaders["Expires"] = "-1";
-            }
-        }
-
-        /// <summary>
-        /// Adds the age header.
-        /// </summary>
-        /// <param name="responseHeaders">The responseHeaders.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        private void AddAgeHeader(IDictionary<string, string> responseHeaders, DateTime? lastDateModified)
-        {
-            if (lastDateModified.HasValue)
-            {
-                responseHeaders["Age"] = Convert.ToInt64((DateTime.UtcNow - lastDateModified.Value).TotalSeconds).ToString(CultureInfo.InvariantCulture);
-            }
-        }
-        /// <summary>
-        /// Determines whether [is not modified] [the specified cache key].
-        /// </summary>
-        /// <param name="requestContext">The request context.</param>
-        /// <param name="cacheKey">The cache key.</param>
-        /// <param name="lastDateModified">The last date modified.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <returns><c>true</c> if [is not modified] [the specified cache key]; otherwise, <c>false</c>.</returns>
-        private bool IsNotModified(IRequest requestContext, Guid? cacheKey, DateTime? lastDateModified, TimeSpan? cacheDuration)
-        {
-            var isNotModified = true;
-
-            var ifModifiedSinceHeader = requestContext.GetHeader("If-Modified-Since");
-
-            if (!string.IsNullOrEmpty(ifModifiedSinceHeader))
-            {
-                DateTime ifModifiedSince;
-
-                if (DateTime.TryParse(ifModifiedSinceHeader, out ifModifiedSince))
-                {
-                    isNotModified = IsNotModified(ifModifiedSince.ToUniversalTime(), cacheDuration, lastDateModified);
-                }
-            }
-
-            var ifNoneMatchHeader = requestContext.GetHeader("If-None-Match");
-
-            // Validate If-None-Match
-            if (isNotModified && (cacheKey.HasValue || !string.IsNullOrEmpty(ifNoneMatchHeader)))
-            {
-                Guid ifNoneMatch;
-
-                if (Guid.TryParse(ifNoneMatchHeader ?? string.Empty, out ifNoneMatch))
-                {
-                    if (cacheKey.HasValue && cacheKey.Value == ifNoneMatch)
-                    {
-                        return true;
-                    }
-                }
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Determines whether [is not modified] [the specified if modified since].
-        /// </summary>
-        /// <param name="ifModifiedSince">If modified since.</param>
-        /// <param name="cacheDuration">Duration of the cache.</param>
-        /// <param name="dateModified">The date modified.</param>
-        /// <returns><c>true</c> if [is not modified] [the specified if modified since]; otherwise, <c>false</c>.</returns>
-        private bool IsNotModified(DateTime ifModifiedSince, TimeSpan? cacheDuration, DateTime? dateModified)
-        {
-            if (dateModified.HasValue)
-            {
-                var lastModified = NormalizeDateForComparison(dateModified.Value);
-                ifModifiedSince = NormalizeDateForComparison(ifModifiedSince);
-
-                return lastModified <= ifModifiedSince;
-            }
-
-            if (cacheDuration.HasValue)
-            {
-                var cacheExpirationDate = ifModifiedSince.Add(cacheDuration.Value);
-
-                if (DateTime.UtcNow < cacheExpirationDate)
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-
-        /// <summary>
-        /// When the browser sends the IfModifiedDate, it's precision is limited to seconds, so this will account for that
-        /// </summary>
-        /// <param name="date">The date.</param>
-        /// <returns>DateTime.</returns>
-        private DateTime NormalizeDateForComparison(DateTime date)
-        {
-            return new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second, date.Kind);
-        }
-
-        /// <summary>
-        /// Adds the response headers.
-        /// </summary>
-        /// <param name="hasHeaders">The has options.</param>
-        /// <param name="responseHeaders">The response headers.</param>
-        private void AddResponseHeaders(IHasHeaders hasHeaders, IEnumerable<KeyValuePair<string, string>> responseHeaders)
-        {
-            foreach (var item in responseHeaders)
-            {
-                hasHeaders.Headers[item.Key] = item.Value;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpRequest.cs b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpRequest.cs
index 95b2ccaba..628e5cc7e 100644
--- a/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpRequest.cs
+++ b/MediaBrowser.Server.Implementations/HttpServer/SocketSharp/WebSocketSharpRequest.cs
@@ -2,12 +2,12 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using Emby.Server.Implementations.HttpServer;
 using Emby.Server.Implementations.HttpServer.SocketSharp;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.Services;
 using ServiceStack;
-using ServiceStack.Host;
 using SocketHttpListener.Net;
 using IHttpFile = MediaBrowser.Model.Services.IHttpFile;
 using IHttpRequest = MediaBrowser.Model.Services.IHttpRequest;
@@ -244,14 +244,15 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             var specifiedContentType = GetQueryStringContentType(httpReq);
             if (!string.IsNullOrEmpty(specifiedContentType)) return specifiedContentType;
 
+            var serverDefaultContentType = "application/json";
+
             var acceptContentTypes = httpReq.AcceptTypes;
             var defaultContentType = httpReq.ContentType;
             if (HasAnyOfContentTypes(httpReq, FormUrlEncoded, MultiPartFormData))
             {
-                defaultContentType = HostContext.Config.DefaultContentType;
+                defaultContentType = serverDefaultContentType;
             }
 
-            var customContentTypes = ContentTypes.Instance.ContentTypeFormats.Values;
             var preferredContentTypes = new string[] {};
 
             var acceptsAnything = false;
@@ -261,7 +262,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
                 var hasPreferredContentTypes = new bool[preferredContentTypes.Length];
                 foreach (var acceptsType in acceptContentTypes)
                 {
-                    var contentType = ContentFormat.GetRealContentType(acceptsType);
+                    var contentType = HttpResultFactory.GetRealContentType(acceptsType);
                     acceptsAnything = acceptsAnything || contentType == "*/*";
 
                     for (var i = 0; i < preferredContentTypes.Length; i++)
@@ -285,17 +286,8 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
                 {
                     if (hasDefaultContentType)
                         return defaultContentType;
-                    if (HostContext.Config.DefaultContentType != null)
-                        return HostContext.Config.DefaultContentType;
-                }
-
-                foreach (var contentType in acceptContentTypes)
-                {
-                    foreach (var customContentType in customContentTypes)
-                    {
-                        if (contentType.StartsWith(customContentType, StringComparison.OrdinalIgnoreCase))
-                            return customContentType;
-                    }
+                    if (serverDefaultContentType != null)
+                        return serverDefaultContentType;
                 }
             }
 
@@ -305,8 +297,9 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             }
 
             //We could also send a '406 Not Acceptable', but this is allowed also
-            return HostContext.Config.DefaultContentType;
+            return serverDefaultContentType;
         }
+
         public const string Soap11 = "text/xml; charset=utf-8";
 
         public static bool HasAnyOfContentTypes(IRequest request, params string[] contentTypes)
@@ -342,10 +335,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             if (format.Contains("json")) return "application/json";
             if (format.Contains("xml")) return Xml;
 
-            string contentType;
-            ContentTypes.Instance.ContentTypeFormats.TryGetValue(format, out contentType);
-
-            return contentType;
+            return null;
         }
 
         public bool HasExplicitResponseContentType { get; private set; }
@@ -357,7 +347,7 @@ namespace MediaBrowser.Server.Implementations.HttpServer.SocketSharp
             {
                 if (this.pathInfo == null)
                 {
-                    var mode = HostContext.Config.HandlerFactoryPath;
+                    var mode = HttpListenerHost.HandlerFactoryPath;
 
                     var pos = request.RawUrl.IndexOf("?");
                     if (pos != -1)
diff --git a/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj b/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
index a2edc7aa8..a253753c5 100644
--- a/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
+++ b/MediaBrowser.Server.Implementations/MediaBrowser.Server.Implementations.csproj
@@ -69,6 +69,10 @@
       <HintPath>..\packages\Patterns.Logging.1.0.0.6\lib\portable-net45+win8\Patterns.Logging.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="ServiceStack.Text, Version=4.5.4.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\ServiceStack.Text.4.5.4\lib\net45\ServiceStack.Text.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="SharpCompress, Version=0.10.3.0, Culture=neutral, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\ThirdParty\SharpCompress\SharpCompress.dll</HintPath>
@@ -88,9 +92,6 @@
     <Reference Include="ServiceStack">
       <HintPath>..\ThirdParty\ServiceStack\ServiceStack.dll</HintPath>
     </Reference>
-    <Reference Include="ServiceStack.Text">
-      <HintPath>..\ThirdParty\ServiceStack.Text\ServiceStack.Text.dll</HintPath>
-    </Reference>
     <Reference Include="System.Xml.Linq" />
     <Reference Include="UniversalDetector, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\UniversalDetector.1.0.1\lib\portable-net45+sl4+wp71+win8+wpa81\UniversalDetector.dll</HintPath>
@@ -109,7 +110,6 @@
     <Compile Include="Devices\CameraUploadsFolder.cs" />
     <Compile Include="EntryPoints\ExternalPortForwarding.cs" />
     <Compile Include="HttpServer\HttpListenerHost.cs" />
-    <Compile Include="HttpServer\HttpResultFactory.cs" />
     <Compile Include="HttpServer\ServerFactory.cs" />
     <Compile Include="HttpServer\SocketSharp\RequestMono.cs" />
     <Compile Include="HttpServer\SocketSharp\WebSocketSharpRequest.cs" />
@@ -141,7 +141,6 @@
     <Compile Include="Persistence\DataExtensions.cs" />
     <Compile Include="Persistence\IDbConnector.cs" />
     <Compile Include="Persistence\MediaStreamColumns.cs" />
-    <Compile Include="Serialization\JsonSerializer.cs" />
     <Compile Include="Social\SharingRepository.cs" />
     <Compile Include="Persistence\SqliteFileOrganizationRepository.cs" />
     <Compile Include="Notifications\SqliteNotificationsRepository.cs" />
@@ -351,7 +350,9 @@
     <None Include="LiveTv\TunerHosts\SatIp\ini\satellite\3594.ini" />
     <None Include="packages.config" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Folder Include="Serialization\" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/MediaBrowser.Server.Implementations/Serialization/JsonSerializer.cs b/MediaBrowser.Server.Implementations/Serialization/JsonSerializer.cs
deleted file mode 100644
index b9a03242c..000000000
--- a/MediaBrowser.Server.Implementations/Serialization/JsonSerializer.cs
+++ /dev/null
@@ -1,227 +0,0 @@
-using System;
-using System.IO;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Serialization;
-
-namespace MediaBrowser.Server.Implementations.Serialization
-{
-    /// <summary>
-    /// Provides a wrapper around third party json serialization.
-    /// </summary>
-    public class JsonSerializer : IJsonSerializer
-    {
-        private readonly IFileSystem _fileSystem;
-        private readonly ILogger _logger;
-
-        public JsonSerializer(IFileSystem fileSystem, ILogger logger)
-        {
-            _fileSystem = fileSystem;
-            _logger = logger;
-            Configure();
-        }
-
-        /// <summary>
-        /// Serializes to stream.
-        /// </summary>
-        /// <param name="obj">The obj.</param>
-        /// <param name="stream">The stream.</param>
-        /// <exception cref="System.ArgumentNullException">obj</exception>
-        public void SerializeToStream(object obj, Stream stream)
-        {
-            if (obj == null)
-            {
-                throw new ArgumentNullException("obj");
-            }
-
-            if (stream == null)
-            {
-                throw new ArgumentNullException("stream");
-            }
-
-            ServiceStack.Text.JsonSerializer.SerializeToStream(obj, obj.GetType(), stream);
-        }
-
-        /// <summary>
-        /// Serializes to file.
-        /// </summary>
-        /// <param name="obj">The obj.</param>
-        /// <param name="file">The file.</param>
-        /// <exception cref="System.ArgumentNullException">obj</exception>
-        public void SerializeToFile(object obj, string file)
-        {
-            if (obj == null)
-            {
-                throw new ArgumentNullException("obj");
-            }
-
-            if (string.IsNullOrEmpty(file))
-            {
-                throw new ArgumentNullException("file");
-            }
-
-			using (Stream stream = _fileSystem.GetFileStream(file, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read))
-            {
-                SerializeToStream(obj, stream);
-            }
-        }
-
-        private Stream OpenFile(string path)
-        {
-            _logger.Debug("Deserializing file {0}", path);
-            return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 131072);
-        }
-
-        /// <summary>
-        /// Deserializes from file.
-        /// </summary>
-        /// <param name="type">The type.</param>
-        /// <param name="file">The file.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">type</exception>
-        public object DeserializeFromFile(Type type, string file)
-        {
-            if (type == null)
-            {
-                throw new ArgumentNullException("type");
-            }
-
-            if (string.IsNullOrEmpty(file))
-            {
-                throw new ArgumentNullException("file");
-            }
-
-            using (Stream stream = OpenFile(file))
-            {
-                return DeserializeFromStream(stream, type);
-            }
-        }
-
-        /// <summary>
-        /// Deserializes from file.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="file">The file.</param>
-        /// <returns>``0.</returns>
-        /// <exception cref="System.ArgumentNullException">file</exception>
-        public T DeserializeFromFile<T>(string file)
-            where T : class
-        {
-            if (string.IsNullOrEmpty(file))
-            {
-                throw new ArgumentNullException("file");
-            }
-
-            using (Stream stream = OpenFile(file))
-            {
-                return DeserializeFromStream<T>(stream);
-            }
-        }
-
-        /// <summary>
-        /// Deserializes from stream.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="stream">The stream.</param>
-        /// <returns>``0.</returns>
-        /// <exception cref="System.ArgumentNullException">stream</exception>
-        public T DeserializeFromStream<T>(Stream stream)
-        {
-            if (stream == null)
-            {
-                throw new ArgumentNullException("stream");
-            }
-
-            return ServiceStack.Text.JsonSerializer.DeserializeFromStream<T>(stream);
-        }
-
-        /// <summary>
-        /// Deserializes from string.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="text">The text.</param>
-        /// <returns>``0.</returns>
-        /// <exception cref="System.ArgumentNullException">text</exception>
-        public T DeserializeFromString<T>(string text)
-        {
-            if (string.IsNullOrEmpty(text))
-            {
-                throw new ArgumentNullException("text");
-            }
-
-            return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(text);
-        }
-
-        /// <summary>
-        /// Deserializes from stream.
-        /// </summary>
-        /// <param name="stream">The stream.</param>
-        /// <param name="type">The type.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">stream</exception>
-        public object DeserializeFromStream(Stream stream, Type type)
-        {
-            if (stream == null)
-            {
-                throw new ArgumentNullException("stream");
-            }
-
-            if (type == null)
-            {
-                throw new ArgumentNullException("type");
-            }
-
-            return ServiceStack.Text.JsonSerializer.DeserializeFromStream(type, stream);
-        }
-
-        /// <summary>
-        /// Configures this instance.
-        /// </summary>
-        private void Configure()
-        {
-            ServiceStack.Text.JsConfig.DateHandler = ServiceStack.Text.DateHandler.ISO8601;
-            ServiceStack.Text.JsConfig.ExcludeTypeInfo = true;
-            ServiceStack.Text.JsConfig.IncludeNullValues = false;
-            ServiceStack.Text.JsConfig.AlwaysUseUtc = true;
-            ServiceStack.Text.JsConfig.AssumeUtc = true;
-        }
-
-        /// <summary>
-        /// Deserializes from string.
-        /// </summary>
-        /// <param name="json">The json.</param>
-        /// <param name="type">The type.</param>
-        /// <returns>System.Object.</returns>
-        /// <exception cref="System.ArgumentNullException">json</exception>
-        public object DeserializeFromString(string json, Type type)
-        {
-            if (string.IsNullOrEmpty(json))
-            {
-                throw new ArgumentNullException("json");
-            }
-
-            if (type == null)
-            {
-                throw new ArgumentNullException("type");
-            }
-
-            return ServiceStack.Text.JsonSerializer.DeserializeFromString(json, type);
-        }
-
-        /// <summary>
-        /// Serializes to string.
-        /// </summary>
-        /// <param name="obj">The obj.</param>
-        /// <returns>System.String.</returns>
-        /// <exception cref="System.ArgumentNullException">obj</exception>
-        public string SerializeToString(object obj)
-        {
-            if (obj == null)
-            {
-                throw new ArgumentNullException("obj");
-            }
-
-            return ServiceStack.Text.JsonSerializer.SerializeToString(obj, obj.GetType());
-        }
-    }
-}
diff --git a/MediaBrowser.Server.Implementations/packages.config b/MediaBrowser.Server.Implementations/packages.config
index 84a5d5a1d..16ac6faf3 100644
--- a/MediaBrowser.Server.Implementations/packages.config
+++ b/MediaBrowser.Server.Implementations/packages.config
@@ -5,5 +5,6 @@
   <package id="MediaBrowser.Naming" version="1.0.0.59" targetFramework="net46" />
   <package id="Microsoft.IO.RecyclableMemoryStream" version="1.1.0.0" targetFramework="net46" />
   <package id="Patterns.Logging" version="1.0.0.6" targetFramework="net46" />
+  <package id="ServiceStack.Text" version="4.5.4" targetFramework="net46" />
   <package id="UniversalDetector" version="1.0.1" targetFramework="net46" />
 </packages>
\ No newline at end of file
diff --git a/MediaBrowser.Server.Startup.Common/ApplicationHost.cs b/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
index c155a968e..e5a17f8fc 100644
--- a/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
+++ b/MediaBrowser.Server.Startup.Common/ApplicationHost.cs
@@ -77,6 +77,7 @@ using System.Threading.Tasks;
 using Emby.Common.Implementations;
 using Emby.Common.Implementations.Networking;
 using Emby.Common.Implementations.Reflection;
+using Emby.Common.Implementations.Serialization;
 using Emby.Common.Implementations.TextEncoding;
 using Emby.Common.Implementations.Updates;
 using Emby.Common.Implementations.Xml;
@@ -103,6 +104,7 @@ using Emby.Server.Implementations.Devices;
 using Emby.Server.Implementations.Dto;
 using Emby.Server.Implementations.EntryPoints;
 using Emby.Server.Implementations.FileOrganization;
+using Emby.Server.Implementations.HttpServer;
 using Emby.Server.Implementations.HttpServer.Security;
 using Emby.Server.Implementations.Library;
 using Emby.Server.Implementations.LiveTv;
@@ -131,7 +133,6 @@ using MediaBrowser.Model.Social;
 using MediaBrowser.Model.Text;
 using MediaBrowser.Model.Xml;
 using MediaBrowser.Server.Implementations.Archiving;
-using MediaBrowser.Server.Implementations.Serialization;
 using OpenSubtitlesHandler;
 using ServiceStack;
 using StringExtensions = MediaBrowser.Controller.Extensions.StringExtensions;
-- 
cgit v1.2.3


From fa714425dd91fed2ca691cd45f73f7ea5a579dff Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Fri, 18 Nov 2016 03:39:20 -0500
Subject: begin to rework repositories

---
 Emby.Server.Core/Activity/ActivityRepository.cs    | 252 -----------
 Emby.Server.Core/ApplicationHost.cs                |  46 +-
 Emby.Server.Core/Devices/DeviceRepository.cs       | 208 ---------
 Emby.Server.Core/Migrations/DbMigration.cs         |   3 +-
 Emby.Server.Core/Migrations/IVersionMigration.cs   |   9 -
 .../Migrations/UpdateLevelMigration.cs             |   1 +
 .../Notifications/SqliteNotificationsRepository.cs | 470 ---------------------
 Emby.Server.Core/Social/SharingRepository.cs       | 158 -------
 .../Activity/ActivityRepository.cs                 | 197 +++++++++
 .../Data/BaseSqliteRepository.cs                   | 123 ++++++
 .../Data/CleanDatabaseScheduledTask.cs             | 361 ++++++++++++++++
 .../Data/SqliteExtensions.cs                       | 105 +++++
 .../Devices/DeviceRepository.cs                    | 208 +++++++++
 .../Emby.Server.Implementations.csproj             |  17 +-
 .../Library/Validators/PeopleValidator.cs          |   6 +-
 .../Migrations/IVersionMigration.cs                |   9 +
 .../Notifications/SqliteNotificationsRepository.cs | 309 ++++++++++++++
 .../Persistence/CleanDatabaseScheduledTask.cs      | 361 ----------------
 .../Social/SharingRepository.cs                    | 114 +++++
 Emby.Server.Implementations/packages.config        |   2 +
 MediaBrowser.Model/Logging/LogHelper.cs            |   4 +-
 .../MediaBrowser.Server.Mono.csproj                |   8 +
 MediaBrowser.Server.Mono/Program.cs                |   2 +
 MediaBrowser.Server.Mono/packages.config           |   2 +
 MediaBrowser.ServerApplication/MainStartup.cs      |   2 +
 .../MediaBrowser.ServerApplication.csproj          |  25 +-
 MediaBrowser.ServerApplication/packages.config     |   3 +-
 src/Emby.Server/Program.cs                         |   1 +
 src/Emby.Server/project.json                       |   3 +-
 29 files changed, 1511 insertions(+), 1498 deletions(-)
 delete mode 100644 Emby.Server.Core/Activity/ActivityRepository.cs
 delete mode 100644 Emby.Server.Core/Devices/DeviceRepository.cs
 delete mode 100644 Emby.Server.Core/Migrations/IVersionMigration.cs
 delete mode 100644 Emby.Server.Core/Notifications/SqliteNotificationsRepository.cs
 delete mode 100644 Emby.Server.Core/Social/SharingRepository.cs
 create mode 100644 Emby.Server.Implementations/Activity/ActivityRepository.cs
 create mode 100644 Emby.Server.Implementations/Data/BaseSqliteRepository.cs
 create mode 100644 Emby.Server.Implementations/Data/CleanDatabaseScheduledTask.cs
 create mode 100644 Emby.Server.Implementations/Data/SqliteExtensions.cs
 create mode 100644 Emby.Server.Implementations/Devices/DeviceRepository.cs
 create mode 100644 Emby.Server.Implementations/Migrations/IVersionMigration.cs
 create mode 100644 Emby.Server.Implementations/Notifications/SqliteNotificationsRepository.cs
 delete mode 100644 Emby.Server.Implementations/Persistence/CleanDatabaseScheduledTask.cs
 create mode 100644 Emby.Server.Implementations/Social/SharingRepository.cs

(limited to 'Emby.Server.Implementations/Library/Validators')

diff --git a/Emby.Server.Core/Activity/ActivityRepository.cs b/Emby.Server.Core/Activity/ActivityRepository.cs
deleted file mode 100644
index c11dcf723..000000000
--- a/Emby.Server.Core/Activity/ActivityRepository.cs
+++ /dev/null
@@ -1,252 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.Globalization;
-using System.IO;
-using System.Threading.Tasks;
-using Emby.Server.Core.Data;
-using MediaBrowser.Controller;
-using MediaBrowser.Model.Activity;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Querying;
-
-namespace Emby.Server.Core.Activity
-{
-    public class ActivityRepository : BaseSqliteRepository, IActivityRepository
-    {
-        private readonly CultureInfo _usCulture = new CultureInfo("en-US");
-
-        public ActivityRepository(ILogManager logManager, IServerApplicationPaths appPaths, IDbConnector connector)
-            : base(logManager, connector)
-        {
-            DbFilePath = Path.Combine(appPaths.DataPath, "activitylog.db");
-        }
-
-        public async Task Initialize()
-        {
-            using (var connection = await CreateConnection().ConfigureAwait(false))
-            {
-                string[] queries = {
-
-                                "create table if not exists ActivityLogEntries (Id GUID PRIMARY KEY, Name TEXT, Overview TEXT, ShortOverview TEXT, Type TEXT, ItemId TEXT, UserId TEXT, DateCreated DATETIME, LogSeverity TEXT)",
-                                "create index if not exists idx_ActivityLogEntries on ActivityLogEntries(Id)"
-                               };
-
-                connection.RunQueries(queries, Logger);
-            }
-        }
-
-        private const string BaseActivitySelectText = "select Id, Name, Overview, ShortOverview, Type, ItemId, UserId, DateCreated, LogSeverity from ActivityLogEntries";
-
-        public Task Create(ActivityLogEntry entry)
-        {
-            return Update(entry);
-        }
-
-        public async Task Update(ActivityLogEntry entry)
-        {
-            if (entry == null)
-            {
-                throw new ArgumentNullException("entry");
-            }
-
-            using (var connection = await CreateConnection().ConfigureAwait(false))
-            {
-                using (var saveActivityCommand = connection.CreateCommand())
-                {
-                    saveActivityCommand.CommandText = "replace into ActivityLogEntries (Id, Name, Overview, ShortOverview, Type, ItemId, UserId, DateCreated, LogSeverity) values (@Id, @Name, @Overview, @ShortOverview, @Type, @ItemId, @UserId, @DateCreated, @LogSeverity)";
-
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@Id");
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@Name");
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@Overview");
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@ShortOverview");
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@Type");
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@ItemId");
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@UserId");
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@DateCreated");
-                    saveActivityCommand.Parameters.Add(saveActivityCommand, "@LogSeverity");
-
-                    IDbTransaction transaction = null;
-
-                    try
-                    {
-                        transaction = connection.BeginTransaction();
-
-                        var index = 0;
-
-                        saveActivityCommand.GetParameter(index++).Value = new Guid(entry.Id);
-                        saveActivityCommand.GetParameter(index++).Value = entry.Name;
-                        saveActivityCommand.GetParameter(index++).Value = entry.Overview;
-                        saveActivityCommand.GetParameter(index++).Value = entry.ShortOverview;
-                        saveActivityCommand.GetParameter(index++).Value = entry.Type;
-                        saveActivityCommand.GetParameter(index++).Value = entry.ItemId;
-                        saveActivityCommand.GetParameter(index++).Value = entry.UserId;
-                        saveActivityCommand.GetParameter(index++).Value = entry.Date;
-                        saveActivityCommand.GetParameter(index++).Value = entry.Severity.ToString();
-
-                        saveActivityCommand.Transaction = transaction;
-
-                        saveActivityCommand.ExecuteNonQuery();
-
-                        transaction.Commit();
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    catch (Exception e)
-                    {
-                        Logger.ErrorException("Failed to save record:", e);
-
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    finally
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Dispose();
-                        }
-                    }
-                }
-            }
-        }
-
-        public QueryResult<ActivityLogEntry> GetActivityLogEntries(DateTime? minDate, int? startIndex, int? limit)
-        {
-            using (var connection = CreateConnection(true).Result)
-            {
-                using (var cmd = connection.CreateCommand())
-                {
-                    cmd.CommandText = BaseActivitySelectText;
-
-                    var whereClauses = new List<string>();
-
-                    if (minDate.HasValue)
-                    {
-                        whereClauses.Add("DateCreated>=@DateCreated");
-                        cmd.Parameters.Add(cmd, "@DateCreated", DbType.Date).Value = minDate.Value;
-                    }
-
-                    var whereTextWithoutPaging = whereClauses.Count == 0 ?
-                        string.Empty :
-                        " where " + string.Join(" AND ", whereClauses.ToArray());
-
-                    if (startIndex.HasValue && startIndex.Value > 0)
-                    {
-                        var pagingWhereText = whereClauses.Count == 0 ?
-                            string.Empty :
-                            " where " + string.Join(" AND ", whereClauses.ToArray());
-
-                        whereClauses.Add(string.Format("Id NOT IN (SELECT Id FROM ActivityLogEntries {0} ORDER BY DateCreated DESC LIMIT {1})",
-                            pagingWhereText,
-                            startIndex.Value.ToString(_usCulture)));
-                    }
-
-                    var whereText = whereClauses.Count == 0 ?
-                        string.Empty :
-                        " where " + string.Join(" AND ", whereClauses.ToArray());
-
-                    cmd.CommandText += whereText;
-
-                    cmd.CommandText += " ORDER BY DateCreated DESC";
-
-                    if (limit.HasValue)
-                    {
-                        cmd.CommandText += " LIMIT " + limit.Value.ToString(_usCulture);
-                    }
-
-                    cmd.CommandText += "; select count (Id) from ActivityLogEntries" + whereTextWithoutPaging;
-
-                    var list = new List<ActivityLogEntry>();
-                    var count = 0;
-
-                    using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
-                    {
-                        while (reader.Read())
-                        {
-                            list.Add(GetEntry(reader));
-                        }
-
-                        if (reader.NextResult() && reader.Read())
-                        {
-                            count = reader.GetInt32(0);
-                        }
-                    }
-
-                    return new QueryResult<ActivityLogEntry>()
-                    {
-                        Items = list.ToArray(),
-                        TotalRecordCount = count
-                    };
-                }
-            }
-        }
-
-        private ActivityLogEntry GetEntry(IDataReader reader)
-        {
-            var index = 0;
-
-            var info = new ActivityLogEntry
-            {
-                Id = reader.GetGuid(index).ToString("N")
-            };
-
-            index++;
-            if (!reader.IsDBNull(index))
-            {
-                info.Name = reader.GetString(index);
-            }
-
-            index++;
-            if (!reader.IsDBNull(index))
-            {
-                info.Overview = reader.GetString(index);
-            }
-
-            index++;
-            if (!reader.IsDBNull(index))
-            {
-                info.ShortOverview = reader.GetString(index);
-            }
-
-            index++;
-            if (!reader.IsDBNull(index))
-            {
-                info.Type = reader.GetString(index);
-            }
-
-            index++;
-            if (!reader.IsDBNull(index))
-            {
-                info.ItemId = reader.GetString(index);
-            }
-
-            index++;
-            if (!reader.IsDBNull(index))
-            {
-                info.UserId = reader.GetString(index);
-            }
-
-            index++;
-            info.Date = reader.GetDateTime(index).ToUniversalTime();
-
-            index++;
-            if (!reader.IsDBNull(index))
-            {
-                info.Severity = (LogSeverity)Enum.Parse(typeof(LogSeverity), reader.GetString(index), true);
-            }
-
-            return info;
-        }
-    }
-}
diff --git a/Emby.Server.Core/ApplicationHost.cs b/Emby.Server.Core/ApplicationHost.cs
index d3d292ca5..7e67c8a08 100644
--- a/Emby.Server.Core/ApplicationHost.cs
+++ b/Emby.Server.Core/ApplicationHost.cs
@@ -83,23 +83,20 @@ using Emby.Dlna.Main;
 using Emby.Dlna.MediaReceiverRegistrar;
 using Emby.Dlna.Ssdp;
 using Emby.Server.Core;
-using Emby.Server.Core.Activity;
+using Emby.Server.Implementations.Activity;
 using Emby.Server.Core.Configuration;
 using Emby.Server.Core.Data;
-using Emby.Server.Core.Devices;
+using Emby.Server.Implementations.Devices;
 using Emby.Server.Core.FFMpeg;
 using Emby.Server.Core.IO;
 using Emby.Server.Core.Localization;
 using Emby.Server.Core.Migrations;
-using Emby.Server.Core.Notifications;
 using Emby.Server.Core.Security;
-using Emby.Server.Core.Social;
+using Emby.Server.Implementations.Social;
 using Emby.Server.Core.Sync;
-using Emby.Server.Implementations.Activity;
 using Emby.Server.Implementations.Channels;
 using Emby.Server.Implementations.Collections;
 using Emby.Server.Implementations.Connect;
-using Emby.Server.Implementations.Devices;
 using Emby.Server.Implementations.Dto;
 using Emby.Server.Implementations.EntryPoints;
 using Emby.Server.Implementations.FileOrganization;
@@ -110,7 +107,7 @@ using Emby.Server.Implementations.LiveTv;
 using Emby.Server.Implementations.Localization;
 using Emby.Server.Implementations.MediaEncoder;
 using Emby.Server.Implementations.Notifications;
-using Emby.Server.Implementations.Persistence;
+using Emby.Server.Implementations.Data;
 using Emby.Server.Implementations.Playlists;
 using Emby.Server.Implementations.Security;
 using Emby.Server.Implementations.ServerManager;
@@ -136,6 +133,7 @@ using ServiceStack;
 using SocketHttpListener.Primitives;
 using StringExtensions = MediaBrowser.Controller.Extensions.StringExtensions;
 using Emby.Drawing;
+using Emby.Server.Implementations.Migrations;
 
 namespace Emby.Server.Core
 {
@@ -282,12 +280,12 @@ namespace Emby.Server.Core
             INetworkManager networkManager,
             Action<string, string> certificateGenerator,
             Func<string> defaultUsernameFactory)
-            : base(applicationPaths, 
-                  logManager, 
-                  fileSystem, 
-                  environmentInfo, 
-                  systemEvents, 
-                  memoryStreamFactory, 
+            : base(applicationPaths,
+                  logManager,
+                  fileSystem,
+                  environmentInfo,
+                  systemEvents,
+                  memoryStreamFactory,
                   networkManager)
         {
             StartupOptions = options;
@@ -683,11 +681,11 @@ namespace Emby.Server.Core
             EncodingManager = new EncodingManager(FileSystemManager, Logger, MediaEncoder, ChapterManager, LibraryManager);
             RegisterSingleInstance(EncodingManager);
 
-            var sharingRepo = new SharingRepository(LogManager, ApplicationPaths, GetDbConnector());
-            await sharingRepo.Initialize().ConfigureAwait(false);
+            var sharingRepo = new SharingRepository(LogManager.GetLogger("SharingRepository"), ApplicationPaths);
+            sharingRepo.Initialize();
             RegisterSingleInstance<ISharingManager>(new SharingManager(sharingRepo, ServerConfigurationManager, LibraryManager, this));
 
-            var activityLogRepo = await GetActivityLogRepository().ConfigureAwait(false);
+            var activityLogRepo = GetActivityLogRepository();
             RegisterSingleInstance(activityLogRepo);
             RegisterSingleInstance<IActivityManager>(new ActivityManager(LogManager.GetLogger("ActivityManager"), activityLogRepo, UserManager));
 
@@ -708,7 +706,7 @@ namespace Emby.Server.Core
             ((UserDataManager)UserDataManager).Repository = userDataRepo;
             await itemRepo.Initialize(userDataRepo).ConfigureAwait(false);
             ((LibraryManager)LibraryManager).ItemRepository = ItemRepository;
-            await ConfigureNotificationsRepository().ConfigureAwait(false);
+            ConfigureNotificationsRepository();
             progress.Report(100);
 
             SetStaticProperties();
@@ -792,7 +790,7 @@ namespace Emby.Server.Core
                 () => SubtitleEncoder,
                 () => MediaSourceManager,
                 HttpClient,
-                ZipClient, 
+                ZipClient,
                 MemoryStreamFactory,
                 ProcessFactory,
                 (Environment.ProcessorCount > 2 ? 14000 : 40000),
@@ -837,11 +835,11 @@ namespace Emby.Server.Core
             return repo;
         }
 
-        private async Task<IActivityRepository> GetActivityLogRepository()
+        private IActivityRepository GetActivityLogRepository()
         {
-            var repo = new ActivityRepository(LogManager, ServerConfigurationManager.ApplicationPaths, GetDbConnector());
+            var repo = new ActivityRepository(LogManager.GetLogger("ActivityRepository"), ServerConfigurationManager.ApplicationPaths);
 
-            await repo.Initialize().ConfigureAwait(false);
+            repo.Initialize();
 
             return repo;
         }
@@ -858,11 +856,11 @@ namespace Emby.Server.Core
         /// <summary>
         /// Configures the repositories.
         /// </summary>
-        private async Task ConfigureNotificationsRepository()
+        private void ConfigureNotificationsRepository()
         {
-            var repo = new SqliteNotificationsRepository(LogManager, ApplicationPaths, GetDbConnector());
+            var repo = new SqliteNotificationsRepository(LogManager.GetLogger("SqliteNotificationsRepository"), ServerConfigurationManager.ApplicationPaths);
 
-            await repo.Initialize().ConfigureAwait(false);
+            repo.Initialize();
 
             NotificationsRepository = repo;
 
diff --git a/Emby.Server.Core/Devices/DeviceRepository.cs b/Emby.Server.Core/Devices/DeviceRepository.cs
deleted file mode 100644
index 63aa7b67a..000000000
--- a/Emby.Server.Core/Devices/DeviceRepository.cs
+++ /dev/null
@@ -1,208 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-using MediaBrowser.Common.Configuration;
-using MediaBrowser.Common.Extensions;
-using MediaBrowser.Controller.Devices;
-using MediaBrowser.Model.Devices;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Serialization;
-using MediaBrowser.Model.Session;
-
-namespace Emby.Server.Core.Devices
-{
-    public class DeviceRepository : IDeviceRepository
-    {
-        private readonly object _syncLock = new object();
-
-        private readonly IApplicationPaths _appPaths;
-        private readonly IJsonSerializer _json;
-        private readonly ILogger _logger;
-        private readonly IFileSystem _fileSystem;
-
-        private Dictionary<string, DeviceInfo> _devices;
-
-        public DeviceRepository(IApplicationPaths appPaths, IJsonSerializer json, ILogger logger, IFileSystem fileSystem)
-        {
-            _appPaths = appPaths;
-            _json = json;
-            _logger = logger;
-            _fileSystem = fileSystem;
-        }
-
-        private string GetDevicesPath()
-        {
-            return Path.Combine(_appPaths.DataPath, "devices");
-        }
-
-        private string GetDevicePath(string id)
-        {
-            return Path.Combine(GetDevicesPath(), id.GetMD5().ToString("N"));
-        }
-
-        public Task SaveDevice(DeviceInfo device)
-        {
-            var path = Path.Combine(GetDevicePath(device.Id), "device.json");
-            _fileSystem.CreateDirectory(Path.GetDirectoryName(path));
-
-            lock (_syncLock)
-            {
-                _json.SerializeToFile(device, path);
-                _devices[device.Id] = device;
-            }
-            return Task.FromResult(true);
-        }
-
-        public Task SaveCapabilities(string reportedId, ClientCapabilities capabilities)
-        {
-            var device = GetDevice(reportedId);
-
-            if (device == null)
-            {
-                throw new ArgumentException("No device has been registed with id " + reportedId);
-            }
-
-            device.Capabilities = capabilities;
-            SaveDevice(device);
-
-            return Task.FromResult(true);
-        }
-
-        public ClientCapabilities GetCapabilities(string reportedId)
-        {
-            var device = GetDevice(reportedId);
-
-            return device == null ? null : device.Capabilities;
-        }
-
-        public DeviceInfo GetDevice(string id)
-        {
-            if (string.IsNullOrWhiteSpace(id))
-            {
-                throw new ArgumentNullException("id");
-            }
-
-            return GetDevices()
-                .FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
-        }
-
-        public IEnumerable<DeviceInfo> GetDevices()
-        {
-            lock (_syncLock)
-            {
-                if (_devices == null)
-                {
-                    _devices = new Dictionary<string, DeviceInfo>(StringComparer.OrdinalIgnoreCase);
-
-                    var devices = LoadDevices().ToList();
-                    foreach (var device in devices)
-                    {
-                        _devices[device.Id] = device;
-                    }
-                }
-                return _devices.Values.ToList();
-            }
-        }
-
-        private IEnumerable<DeviceInfo> LoadDevices()
-        {
-            var path = GetDevicesPath();
-
-            try
-            {
-                return _fileSystem
-                    .GetFilePaths(path, true)
-                    .Where(i => string.Equals(Path.GetFileName(i), "device.json", StringComparison.OrdinalIgnoreCase))
-                    .ToList()
-                    .Select(i =>
-                    {
-                        try
-                        {
-                            return _json.DeserializeFromFile<DeviceInfo>(i);
-                        }
-                        catch (Exception ex)
-                        {
-                            _logger.ErrorException("Error reading {0}", ex, i);
-                            return null;
-                        }
-                    })
-                    .Where(i => i != null);
-            }
-            catch (IOException)
-            {
-                return new List<DeviceInfo>();
-            }
-        }
-
-        public Task DeleteDevice(string id)
-        {
-            var path = GetDevicePath(id);
-
-            lock (_syncLock)
-            {
-                try
-                {
-                    _fileSystem.DeleteDirectory(path, true);
-                }
-                catch (DirectoryNotFoundException)
-                {
-                }
-
-                _devices = null;
-            }
-
-            return Task.FromResult(true);
-        }
-
-        public ContentUploadHistory GetCameraUploadHistory(string deviceId)
-        {
-            var path = Path.Combine(GetDevicePath(deviceId), "camerauploads.json");
-
-            lock (_syncLock)
-            {
-                try
-                {
-                    return _json.DeserializeFromFile<ContentUploadHistory>(path);
-                }
-                catch (IOException)
-                {
-                    return new ContentUploadHistory
-                    {
-                        DeviceId = deviceId
-                    };
-                }
-            }
-        }
-
-        public void AddCameraUpload(string deviceId, LocalFileInfo file)
-        {
-            var path = Path.Combine(GetDevicePath(deviceId), "camerauploads.json");
-            _fileSystem.CreateDirectory(Path.GetDirectoryName(path));
-
-            lock (_syncLock)
-            {
-                ContentUploadHistory history;
-
-                try
-                {
-                    history = _json.DeserializeFromFile<ContentUploadHistory>(path);
-                }
-                catch (IOException)
-                {
-                    history = new ContentUploadHistory
-                    {
-                        DeviceId = deviceId
-                    };
-                }
-
-                history.DeviceId = deviceId;
-                history.FilesUploaded.Add(file);
-
-                _json.SerializeToFile(history, path);
-            }
-        }
-    }
-}
diff --git a/Emby.Server.Core/Migrations/DbMigration.cs b/Emby.Server.Core/Migrations/DbMigration.cs
index 17e086093..5d652770f 100644
--- a/Emby.Server.Core/Migrations/DbMigration.cs
+++ b/Emby.Server.Core/Migrations/DbMigration.cs
@@ -1,8 +1,9 @@
 using System.Threading.Tasks;
-using Emby.Server.Implementations.Persistence;
+using Emby.Server.Implementations.Data;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Model.Tasks;
 using Emby.Server.Core.Data;
+using Emby.Server.Implementations.Migrations;
 
 namespace Emby.Server.Core.Migrations
 {
diff --git a/Emby.Server.Core/Migrations/IVersionMigration.cs b/Emby.Server.Core/Migrations/IVersionMigration.cs
deleted file mode 100644
index 0190e289a..000000000
--- a/Emby.Server.Core/Migrations/IVersionMigration.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-using System.Threading.Tasks;
-
-namespace Emby.Server.Core.Migrations
-{
-    public interface IVersionMigration
-    {
-        Task Run();
-    }
-}
diff --git a/Emby.Server.Core/Migrations/UpdateLevelMigration.cs b/Emby.Server.Core/Migrations/UpdateLevelMigration.cs
index bbedd7b63..c79dbabea 100644
--- a/Emby.Server.Core/Migrations/UpdateLevelMigration.cs
+++ b/Emby.Server.Core/Migrations/UpdateLevelMigration.cs
@@ -9,6 +9,7 @@ using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Model.Logging;
 using MediaBrowser.Model.Serialization;
 using MediaBrowser.Model.Updates;
+using Emby.Server.Implementations.Migrations;
 
 namespace Emby.Server.Core.Migrations
 {
diff --git a/Emby.Server.Core/Notifications/SqliteNotificationsRepository.cs b/Emby.Server.Core/Notifications/SqliteNotificationsRepository.cs
deleted file mode 100644
index cd4ac28dc..000000000
--- a/Emby.Server.Core/Notifications/SqliteNotificationsRepository.cs
+++ /dev/null
@@ -1,470 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Data;
-using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Emby.Server.Core.Data;
-using MediaBrowser.Controller;
-using MediaBrowser.Controller.Notifications;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Notifications;
-
-namespace Emby.Server.Core.Notifications
-{
-    public class SqliteNotificationsRepository : BaseSqliteRepository, INotificationsRepository
-    {
-        public SqliteNotificationsRepository(ILogManager logManager, IServerApplicationPaths appPaths, IDbConnector dbConnector) : base(logManager, dbConnector)
-        {
-            DbFilePath = Path.Combine(appPaths.DataPath, "notifications.db");
-        }
-
-        public event EventHandler<NotificationUpdateEventArgs> NotificationAdded;
-        public event EventHandler<NotificationReadEventArgs> NotificationsMarkedRead;
-        ////public event EventHandler<NotificationUpdateEventArgs> NotificationUpdated;
-
-        public async Task Initialize()
-        {
-            using (var connection = await CreateConnection().ConfigureAwait(false))
-            {
-                string[] queries = {
-
-                                "create table if not exists Notifications (Id GUID NOT NULL, UserId GUID NOT NULL, Date DATETIME NOT NULL, Name TEXT NOT NULL, Description TEXT NULL, Url TEXT NULL, Level TEXT NOT NULL, IsRead BOOLEAN NOT NULL, Category TEXT NOT NULL, RelatedId TEXT NULL, PRIMARY KEY (Id, UserId))",
-                                "create index if not exists idx_Notifications1 on Notifications(Id)",
-                                "create index if not exists idx_Notifications2 on Notifications(UserId)"
-                               };
-
-                connection.RunQueries(queries, Logger);
-            }
-        }
-
-        /// <summary>
-        /// Gets the notifications.
-        /// </summary>
-        /// <param name="query">The query.</param>
-        /// <returns>NotificationResult.</returns>
-        public NotificationResult GetNotifications(NotificationQuery query)
-        {
-            var result = new NotificationResult();
-
-            using (var connection = CreateConnection(true).Result)
-            {
-                using (var cmd = connection.CreateCommand())
-                {
-                    var clauses = new List<string>();
-
-                    if (query.IsRead.HasValue)
-                    {
-                        clauses.Add("IsRead=@IsRead");
-                        cmd.Parameters.Add(cmd, "@IsRead", DbType.Boolean).Value = query.IsRead.Value;
-                    }
-
-                    clauses.Add("UserId=@UserId");
-                    cmd.Parameters.Add(cmd, "@UserId", DbType.Guid).Value = new Guid(query.UserId);
-
-                    var whereClause = " where " + string.Join(" And ", clauses.ToArray());
-
-                    cmd.CommandText = string.Format("select count(Id) from Notifications{0};select Id,UserId,Date,Name,Description,Url,Level,IsRead,Category,RelatedId from Notifications{0} order by IsRead asc, Date desc", whereClause);
-
-                    using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
-                    {
-                        if (reader.Read())
-                        {
-                            result.TotalRecordCount = reader.GetInt32(0);
-                        }
-
-                        if (reader.NextResult())
-                        {
-                            var notifications = GetNotifications(reader);
-
-                            if (query.StartIndex.HasValue)
-                            {
-                                notifications = notifications.Skip(query.StartIndex.Value);
-                            }
-
-                            if (query.Limit.HasValue)
-                            {
-                                notifications = notifications.Take(query.Limit.Value);
-                            }
-
-                            result.Notifications = notifications.ToArray();
-                        }
-                    }
-
-                    return result;
-                }
-            }
-        }
-
-        public NotificationsSummary GetNotificationsSummary(string userId)
-        {
-            var result = new NotificationsSummary();
-
-            using (var connection = CreateConnection(true).Result)
-            {
-                using (var cmd = connection.CreateCommand())
-                {
-                    cmd.CommandText = "select Level from Notifications where UserId=@UserId and IsRead=@IsRead";
-
-                    cmd.Parameters.Add(cmd, "@UserId", DbType.Guid).Value = new Guid(userId);
-                    cmd.Parameters.Add(cmd, "@IsRead", DbType.Boolean).Value = false;
-
-                    using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
-                    {
-                        var levels = new List<NotificationLevel>();
-
-                        while (reader.Read())
-                        {
-                            levels.Add(GetLevel(reader, 0));
-                        }
-
-                        result.UnreadCount = levels.Count;
-
-                        if (levels.Count > 0)
-                        {
-                            result.MaxUnreadNotificationLevel = levels.Max();
-                        }
-                    }
-
-                    return result;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Gets the notifications.
-        /// </summary>
-        /// <param name="reader">The reader.</param>
-        /// <returns>IEnumerable{Notification}.</returns>
-        private IEnumerable<Notification> GetNotifications(IDataReader reader)
-        {
-            var list = new List<Notification>();
-
-            while (reader.Read())
-            {
-                list.Add(GetNotification(reader));
-            }
-
-            return list;
-        }
-
-        private Notification GetNotification(IDataReader reader)
-        {
-            var notification = new Notification
-            {
-                Id = reader.GetGuid(0).ToString("N"),
-                UserId = reader.GetGuid(1).ToString("N"),
-                Date = reader.GetDateTime(2).ToUniversalTime(),
-                Name = reader.GetString(3)
-            };
-
-            if (!reader.IsDBNull(4))
-            {
-                notification.Description = reader.GetString(4);
-            }
-
-            if (!reader.IsDBNull(5))
-            {
-                notification.Url = reader.GetString(5);
-            }
-
-            notification.Level = GetLevel(reader, 6);
-            notification.IsRead = reader.GetBoolean(7);
-
-            return notification;
-        }
-
-        /// <summary>
-        /// Gets the level.
-        /// </summary>
-        /// <param name="reader">The reader.</param>
-        /// <param name="index">The index.</param>
-        /// <returns>NotificationLevel.</returns>
-        private NotificationLevel GetLevel(IDataReader reader, int index)
-        {
-            NotificationLevel level;
-
-            var val = reader.GetString(index);
-
-            Enum.TryParse(val, true, out level);
-
-            return level;
-        }
-
-        /// <summary>
-        /// Adds the notification.
-        /// </summary>
-        /// <param name="notification">The notification.</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns>Task.</returns>
-        public async Task AddNotification(Notification notification, CancellationToken cancellationToken)
-        {
-            await ReplaceNotification(notification, cancellationToken).ConfigureAwait(false);
-
-            if (NotificationAdded != null)
-            {
-                try
-                {
-                    NotificationAdded(this, new NotificationUpdateEventArgs
-                    {
-                        Notification = notification
-                    });
-                }
-                catch (Exception ex)
-                {
-                    Logger.ErrorException("Error in NotificationAdded event handler", ex);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Replaces the notification.
-        /// </summary>
-        /// <param name="notification">The notification.</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns>Task.</returns>
-        private async Task ReplaceNotification(Notification notification, CancellationToken cancellationToken)
-        {
-            if (string.IsNullOrEmpty(notification.Id))
-            {
-                notification.Id = Guid.NewGuid().ToString("N");
-            }
-            if (string.IsNullOrEmpty(notification.UserId))
-            {
-                throw new ArgumentException("The notification must have a user id");
-            }
-
-            cancellationToken.ThrowIfCancellationRequested();
-
-            using (var connection = await CreateConnection().ConfigureAwait(false))
-            {
-                using (var replaceNotificationCommand = connection.CreateCommand())
-                {
-                    replaceNotificationCommand.CommandText = "replace into Notifications (Id, UserId, Date, Name, Description, Url, Level, IsRead, Category, RelatedId) values (@Id, @UserId, @Date, @Name, @Description, @Url, @Level, @IsRead, @Category, @RelatedId)";
-
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@Id");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@UserId");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@Date");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@Name");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@Description");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@Url");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@Level");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@IsRead");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@Category");
-                    replaceNotificationCommand.Parameters.Add(replaceNotificationCommand, "@RelatedId");
-
-                    IDbTransaction transaction = null;
-
-                    try
-                    {
-                        transaction = connection.BeginTransaction();
-
-                        replaceNotificationCommand.GetParameter("@Id").Value = new Guid(notification.Id);
-                        replaceNotificationCommand.GetParameter("@UserId").Value = new Guid(notification.UserId);
-                        replaceNotificationCommand.GetParameter("@Date").Value = notification.Date.ToUniversalTime();
-                        replaceNotificationCommand.GetParameter("@Name").Value = notification.Name;
-                        replaceNotificationCommand.GetParameter("@Description").Value = notification.Description;
-                        replaceNotificationCommand.GetParameter("@Url").Value = notification.Url;
-                        replaceNotificationCommand.GetParameter("@Level").Value = notification.Level.ToString();
-                        replaceNotificationCommand.GetParameter("@IsRead").Value = notification.IsRead;
-                        replaceNotificationCommand.GetParameter("@Category").Value = string.Empty;
-                        replaceNotificationCommand.GetParameter("@RelatedId").Value = string.Empty;
-
-                        replaceNotificationCommand.Transaction = transaction;
-
-                        replaceNotificationCommand.ExecuteNonQuery();
-
-                        transaction.Commit();
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    catch (Exception e)
-                    {
-                        Logger.ErrorException("Failed to save notification:", e);
-
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    finally
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Dispose();
-                        }
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Marks the read.
-        /// </summary>
-        /// <param name="notificationIdList">The notification id list.</param>
-        /// <param name="userId">The user id.</param>
-        /// <param name="isRead">if set to <c>true</c> [is read].</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns>Task.</returns>
-        public async Task MarkRead(IEnumerable<string> notificationIdList, string userId, bool isRead, CancellationToken cancellationToken)
-        {
-            var list = notificationIdList.ToList();
-            var idArray = list.Select(i => new Guid(i)).ToArray();
-
-            await MarkReadInternal(idArray, userId, isRead, cancellationToken).ConfigureAwait(false);
-
-            if (NotificationsMarkedRead != null)
-            {
-                try
-                {
-                    NotificationsMarkedRead(this, new NotificationReadEventArgs
-                    {
-                        IdList = list.ToArray(),
-                        IsRead = isRead,
-                        UserId = userId
-                    });
-                }
-                catch (Exception ex)
-                {
-                    Logger.ErrorException("Error in NotificationsMarkedRead event handler", ex);
-                }
-            }
-        }
-
-        public async Task MarkAllRead(string userId, bool isRead, CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            using (var connection = await CreateConnection().ConfigureAwait(false))
-            {
-                using (var markAllReadCommand = connection.CreateCommand())
-                {
-                    markAllReadCommand.CommandText = "update Notifications set IsRead=@IsRead where UserId=@UserId";
-
-                    markAllReadCommand.Parameters.Add(markAllReadCommand, "@UserId");
-                    markAllReadCommand.Parameters.Add(markAllReadCommand, "@IsRead");
-
-                    IDbTransaction transaction = null;
-
-                    try
-                    {
-                        cancellationToken.ThrowIfCancellationRequested();
-
-                        transaction = connection.BeginTransaction();
-
-                        markAllReadCommand.GetParameter(0).Value = new Guid(userId);
-                        markAllReadCommand.GetParameter(1).Value = isRead;
-
-                        markAllReadCommand.ExecuteNonQuery();
-
-                        transaction.Commit();
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    catch (Exception e)
-                    {
-                        Logger.ErrorException("Failed to save notification:", e);
-
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    finally
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Dispose();
-                        }
-                    }
-                }
-            }
-        }
-
-        private async Task MarkReadInternal(IEnumerable<Guid> notificationIdList, string userId, bool isRead, CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            using (var connection = await CreateConnection().ConfigureAwait(false))
-            {
-                using (var markReadCommand = connection.CreateCommand())
-                {
-                    markReadCommand.CommandText = "update Notifications set IsRead=@IsRead where Id=@Id and UserId=@UserId";
-
-                    markReadCommand.Parameters.Add(markReadCommand, "@UserId");
-                    markReadCommand.Parameters.Add(markReadCommand, "@IsRead");
-                    markReadCommand.Parameters.Add(markReadCommand, "@Id");
-
-                    IDbTransaction transaction = null;
-
-                    try
-                    {
-                        cancellationToken.ThrowIfCancellationRequested();
-
-                        transaction = connection.BeginTransaction();
-
-                        markReadCommand.GetParameter(0).Value = new Guid(userId);
-                        markReadCommand.GetParameter(1).Value = isRead;
-
-                        foreach (var id in notificationIdList)
-                        {
-                            markReadCommand.GetParameter(2).Value = id;
-
-                            markReadCommand.Transaction = transaction;
-
-                            markReadCommand.ExecuteNonQuery();
-                        }
-
-                        transaction.Commit();
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    catch (Exception e)
-                    {
-                        Logger.ErrorException("Failed to save notification:", e);
-
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    finally
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Dispose();
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/Emby.Server.Core/Social/SharingRepository.cs b/Emby.Server.Core/Social/SharingRepository.cs
deleted file mode 100644
index 5503b7ab3..000000000
--- a/Emby.Server.Core/Social/SharingRepository.cs
+++ /dev/null
@@ -1,158 +0,0 @@
-using System;
-using System.Data;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using Emby.Server.Core.Data;
-using MediaBrowser.Common.Configuration;
-using MediaBrowser.Model.Logging;
-using MediaBrowser.Model.Social;
-
-namespace Emby.Server.Core.Social
-{
-    public class SharingRepository : BaseSqliteRepository, ISharingRepository
-    {
-        public SharingRepository(ILogManager logManager, IApplicationPaths appPaths, IDbConnector dbConnector)
-            : base(logManager, dbConnector)
-        {
-            DbFilePath = Path.Combine(appPaths.DataPath, "shares.db");
-        }
-
-        /// <summary>
-        /// Opens the connection to the database
-        /// </summary>
-        /// <returns>Task.</returns>
-        public async Task Initialize()
-        {
-            using (var connection = await CreateConnection().ConfigureAwait(false))
-            {
-                string[] queries = {
-
-                                "create table if not exists Shares (Id GUID, ItemId TEXT, UserId TEXT, ExpirationDate DateTime, PRIMARY KEY (Id))",
-                                "create index if not exists idx_Shares on Shares(Id)",
-
-                                "pragma shrink_memory"
-                               };
-
-                connection.RunQueries(queries, Logger);
-            }
-        }
-
-        public async Task CreateShare(SocialShareInfo info)
-        {
-            if (info == null)
-            {
-                throw new ArgumentNullException("info");
-            }
-            if (string.IsNullOrWhiteSpace(info.Id))
-            {
-                throw new ArgumentNullException("info.Id");
-            }
-
-            var cancellationToken = CancellationToken.None;
-
-            cancellationToken.ThrowIfCancellationRequested();
-
-            using (var connection = await CreateConnection().ConfigureAwait(false))
-            {
-                using (var saveShareCommand = connection.CreateCommand())
-                {
-                    saveShareCommand.CommandText = "replace into Shares (Id, ItemId, UserId, ExpirationDate) values (@Id, @ItemId, @UserId, @ExpirationDate)";
-
-                    saveShareCommand.Parameters.Add(saveShareCommand, "@Id");
-                    saveShareCommand.Parameters.Add(saveShareCommand, "@ItemId");
-                    saveShareCommand.Parameters.Add(saveShareCommand, "@UserId");
-                    saveShareCommand.Parameters.Add(saveShareCommand, "@ExpirationDate");
-
-                    IDbTransaction transaction = null;
-
-                    try
-                    {
-                        transaction = connection.BeginTransaction();
-
-                        saveShareCommand.GetParameter(0).Value = new Guid(info.Id);
-                        saveShareCommand.GetParameter(1).Value = info.ItemId;
-                        saveShareCommand.GetParameter(2).Value = info.UserId;
-                        saveShareCommand.GetParameter(3).Value = info.ExpirationDate;
-
-                        saveShareCommand.Transaction = transaction;
-
-                        saveShareCommand.ExecuteNonQuery();
-
-                        transaction.Commit();
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    catch (Exception e)
-                    {
-                        Logger.ErrorException("Failed to save share:", e);
-
-                        if (transaction != null)
-                        {
-                            transaction.Rollback();
-                        }
-
-                        throw;
-                    }
-                    finally
-                    {
-                        if (transaction != null)
-                        {
-                            transaction.Dispose();
-                        }
-                    }
-                }
-            }
-        }
-
-        public SocialShareInfo GetShareInfo(string id)
-        {
-            if (string.IsNullOrWhiteSpace(id))
-            {
-                throw new ArgumentNullException("id");
-            }
-
-            using (var connection = CreateConnection(true).Result)
-            {
-                var cmd = connection.CreateCommand();
-                cmd.CommandText = "select Id, ItemId, UserId, ExpirationDate from Shares where id = @id";
-
-                cmd.Parameters.Add(cmd, "@id", DbType.Guid).Value = new Guid(id);
-
-                using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult | CommandBehavior.SingleRow))
-                {
-                    if (reader.Read())
-                    {
-                        return GetSocialShareInfo(reader);
-                    }
-                }
-
-                return null;
-            }
-        }
-
-        private SocialShareInfo GetSocialShareInfo(IDataReader reader)
-        {
-            var info = new SocialShareInfo();
-
-            info.Id = reader.GetGuid(0).ToString("N");
-            info.ItemId = reader.GetString(1);
-            info.UserId = reader.GetString(2);
-            info.ExpirationDate = reader.GetDateTime(3).ToUniversalTime();
-
-            return info;
-        }
-
-        public async Task DeleteShare(string id)
-        {
-
-        }
-    }
-}
diff --git a/Emby.Server.Implementations/Activity/ActivityRepository.cs b/Emby.Server.Implementations/Activity/ActivityRepository.cs
new file mode 100644
index 000000000..ea9e537c9
--- /dev/null
+++ b/Emby.Server.Implementations/Activity/ActivityRepository.cs
@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Emby.Server.Implementations.Data;
+using MediaBrowser.Controller;
+using MediaBrowser.Model.Activity;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Querying;
+using SQLitePCL.pretty;
+
+namespace Emby.Server.Implementations.Activity
+{
+    public class ActivityRepository : BaseSqliteRepository, IActivityRepository
+    {
+        private readonly CultureInfo _usCulture = new CultureInfo("en-US");
+
+        public ActivityRepository(ILogger logger, IServerApplicationPaths appPaths)
+            : base(logger)
+        {
+            DbFilePath = Path.Combine(appPaths.DataPath, "activitylog.db");
+        }
+
+        public void Initialize()
+        {
+            using (var connection = CreateConnection())
+            {
+                string[] queries = {
+
+                                "create table if not exists ActivityLogEntries (Id GUID PRIMARY KEY, Name TEXT, Overview TEXT, ShortOverview TEXT, Type TEXT, ItemId TEXT, UserId TEXT, DateCreated DATETIME, LogSeverity TEXT)",
+                                "create index if not exists idx_ActivityLogEntries on ActivityLogEntries(Id)"
+                               };
+
+                connection.RunQueries(queries);
+            }
+        }
+
+        private const string BaseActivitySelectText = "select Id, Name, Overview, ShortOverview, Type, ItemId, UserId, DateCreated, LogSeverity from ActivityLogEntries";
+
+        public Task Create(ActivityLogEntry entry)
+        {
+            return Update(entry);
+        }
+
+        public async Task Update(ActivityLogEntry entry)
+        {
+            if (entry == null)
+            {
+                throw new ArgumentNullException("entry");
+            }
+
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection())
+                {
+                    connection.RunInTransaction(db =>
+                    {
+                        var commandText = "replace into ActivityLogEntries (Id, Name, Overview, ShortOverview, Type, ItemId, UserId, DateCreated, LogSeverity) values (?, ?, ?, ?, ?, ?, ?, ?, ?)";
+
+                        db.Execute(commandText,
+                            entry.Id.ToGuidParamValue(),
+                            entry.Name,
+                            entry.Overview,
+                            entry.ShortOverview,
+                            entry.Type,
+                            entry.ItemId,
+                            entry.UserId,
+                            entry.Date.ToDateTimeParamValue(),
+                            entry.Severity.ToString());
+                    });
+                }
+            }
+        }
+
+        public QueryResult<ActivityLogEntry> GetActivityLogEntries(DateTime? minDate, int? startIndex, int? limit)
+        {
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection(true))
+                {
+                    var commandText = BaseActivitySelectText;
+
+                    var whereClauses = new List<string>();
+                    var paramList = new List<object>();
+
+                    if (minDate.HasValue)
+                    {
+                        whereClauses.Add("DateCreated>=@DateCreated");
+                        paramList.Add(minDate.Value.ToDateTimeParamValue());
+                    }
+
+                    var whereTextWithoutPaging = whereClauses.Count == 0 ?
+                        string.Empty :
+                        " where " + string.Join(" AND ", whereClauses.ToArray());
+
+                    if (startIndex.HasValue && startIndex.Value > 0)
+                    {
+                        var pagingWhereText = whereClauses.Count == 0 ?
+                            string.Empty :
+                            " where " + string.Join(" AND ", whereClauses.ToArray());
+
+                        whereClauses.Add(string.Format("Id NOT IN (SELECT Id FROM ActivityLogEntries {0} ORDER BY DateCreated DESC LIMIT {1})",
+                            pagingWhereText,
+                            startIndex.Value.ToString(_usCulture)));
+                    }
+
+                    var whereText = whereClauses.Count == 0 ?
+                        string.Empty :
+                        " where " + string.Join(" AND ", whereClauses.ToArray());
+
+                    commandText += whereText;
+
+                    commandText += " ORDER BY DateCreated DESC";
+
+                    if (limit.HasValue)
+                    {
+                        commandText += " LIMIT " + limit.Value.ToString(_usCulture);
+                    }
+
+                    var totalRecordCount = connection.Query("select count (Id) from ActivityLogEntries" + whereTextWithoutPaging, paramList.ToArray()).SelectScalarInt().First();
+
+                    var list = new List<ActivityLogEntry>();
+
+                    foreach (var row in connection.Query(commandText, paramList.ToArray()))
+                    {
+                        list.Add(GetEntry(row));
+                    }
+
+                    return new QueryResult<ActivityLogEntry>()
+                    {
+                        Items = list.ToArray(),
+                        TotalRecordCount = totalRecordCount
+                    };
+                }
+            }
+        }
+
+        private ActivityLogEntry GetEntry(IReadOnlyList<IResultSetValue> reader)
+        {
+            var index = 0;
+
+            var info = new ActivityLogEntry
+            {
+                Id = reader[index].ReadGuid().ToString("N")
+            };
+
+            index++;
+            if (reader[index].SQLiteType != SQLiteType.Null)
+            {
+                info.Name = reader[index].ToString();
+            }
+
+            index++;
+            if (reader[index].SQLiteType != SQLiteType.Null)
+            {
+                info.Overview = reader[index].ToString();
+            }
+
+            index++;
+            if (reader[index].SQLiteType != SQLiteType.Null)
+            {
+                info.ShortOverview = reader[index].ToString();
+            }
+
+            index++;
+            if (reader[index].SQLiteType != SQLiteType.Null)
+            {
+                info.Type = reader[index].ToString();
+            }
+
+            index++;
+            if (reader[index].SQLiteType != SQLiteType.Null)
+            {
+                info.ItemId = reader[index].ToString();
+            }
+
+            index++;
+            if (reader[index].SQLiteType != SQLiteType.Null)
+            {
+                info.UserId = reader[index].ToString();
+            }
+
+            index++;
+            info.Date = reader[index].ReadDateTime();
+
+            index++;
+            if (reader[index].SQLiteType != SQLiteType.Null)
+            {
+                info.Severity = (LogSeverity)Enum.Parse(typeof(LogSeverity), reader[index].ToString(), true);
+            }
+
+            return info;
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Data/BaseSqliteRepository.cs b/Emby.Server.Implementations/Data/BaseSqliteRepository.cs
new file mode 100644
index 000000000..c7ac630a0
--- /dev/null
+++ b/Emby.Server.Implementations/Data/BaseSqliteRepository.cs
@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Logging;
+using SQLitePCL.pretty;
+
+namespace Emby.Server.Implementations.Data
+{
+    public abstract class BaseSqliteRepository : IDisposable
+    {
+        protected string DbFilePath { get; set; }
+        protected SemaphoreSlim WriteLock = new SemaphoreSlim(1, 1);
+        protected ILogger Logger { get; private set; }
+
+        protected BaseSqliteRepository(ILogger logger)
+        {
+            Logger = logger;
+        }
+
+        protected virtual bool EnableConnectionPooling
+        {
+            get { return true; }
+        }
+
+        protected virtual SQLiteDatabaseConnection CreateConnection(bool isReadOnly = false)
+        {
+            SQLite3.EnableSharedCache = false;
+
+            ConnectionFlags connectionFlags;
+
+            if (isReadOnly)
+            {
+                connectionFlags = ConnectionFlags.ReadOnly;
+                //connectionFlags = ConnectionFlags.Create;
+                //connectionFlags |= ConnectionFlags.ReadWrite;
+            }
+            else
+            {
+                connectionFlags = ConnectionFlags.Create;
+                connectionFlags |= ConnectionFlags.ReadWrite;
+            }
+
+            if (EnableConnectionPooling)
+            {
+                connectionFlags |= ConnectionFlags.SharedCached;
+            }
+            else
+            {
+                connectionFlags |= ConnectionFlags.PrivateCache;
+            }
+
+            connectionFlags |= ConnectionFlags.NoMutex;
+
+            var db = SQLite3.Open(DbFilePath, connectionFlags, null);
+
+            var queries = new[]
+            {
+                "PRAGMA page_size=4096",
+                "PRAGMA journal_mode=WAL",
+                "PRAGMA temp_store=memory",
+                "PRAGMA synchronous=Normal",
+                //"PRAGMA cache size=-10000"
+                };
+
+            //foreach (var query in queries)
+            //{
+            //    db.Execute(query);
+            //}
+
+            db.ExecuteAll(string.Join(";", queries));
+
+            return db;
+        }
+
+        private bool _disposed;
+        protected void CheckDisposed()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(GetType().Name + " has been disposed and cannot be accessed.");
+            }
+        }
+
+        public void Dispose()
+        {
+            _disposed = true;
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private readonly object _disposeLock = new object();
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool dispose)
+        {
+            if (dispose)
+            {
+                try
+                {
+                    lock (_disposeLock)
+                    {
+                        WriteLock.Wait();
+
+                        CloseConnection();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logger.ErrorException("Error disposing database", ex);
+                }
+            }
+        }
+
+        protected virtual void CloseConnection()
+        {
+
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Data/CleanDatabaseScheduledTask.cs b/Emby.Server.Implementations/Data/CleanDatabaseScheduledTask.cs
new file mode 100644
index 000000000..dd32e2cbd
--- /dev/null
+++ b/Emby.Server.Implementations/Data/CleanDatabaseScheduledTask.cs
@@ -0,0 +1,361 @@
+using MediaBrowser.Common.Progress;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Common.IO;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Controller.Channels;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.IO;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.Net;
+using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.Tasks;
+using Emby.Server.Implementations.ScheduledTasks;
+
+namespace Emby.Server.Implementations.Data
+{
+    public class CleanDatabaseScheduledTask : IScheduledTask
+    {
+        private readonly ILibraryManager _libraryManager;
+        private readonly IItemRepository _itemRepo;
+        private readonly ILogger _logger;
+        private readonly IServerConfigurationManager _config;
+        private readonly IFileSystem _fileSystem;
+        private readonly IHttpServer _httpServer;
+        private readonly ILocalizationManager _localization;
+        private readonly ITaskManager _taskManager;
+
+        public const int MigrationVersion = 23;
+        public static bool EnableUnavailableMessage = false;
+        const int LatestSchemaVersion = 109;
+
+        public CleanDatabaseScheduledTask(ILibraryManager libraryManager, IItemRepository itemRepo, ILogger logger, IServerConfigurationManager config, IFileSystem fileSystem, IHttpServer httpServer, ILocalizationManager localization, ITaskManager taskManager)
+        {
+            _libraryManager = libraryManager;
+            _itemRepo = itemRepo;
+            _logger = logger;
+            _config = config;
+            _fileSystem = fileSystem;
+            _httpServer = httpServer;
+            _localization = localization;
+            _taskManager = taskManager;
+        }
+
+        public string Name
+        {
+            get { return "Clean Database"; }
+        }
+
+        public string Description
+        {
+            get { return "Deletes obsolete content from the database."; }
+        }
+
+        public string Category
+        {
+            get { return "Library"; }
+        }
+
+        public async Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
+        {
+            OnProgress(0);
+
+            // Ensure these objects are lazy loaded.
+            // Without this there is a deadlock that will need to be investigated
+            var rootChildren = _libraryManager.RootFolder.Children.ToList();
+            rootChildren = _libraryManager.GetUserRootFolder().Children.ToList();
+
+            var innerProgress = new ActionableProgress<double>();
+            innerProgress.RegisterAction(p =>
+            {
+                double newPercentCommplete = .4 * p;
+                OnProgress(newPercentCommplete);
+
+                progress.Report(newPercentCommplete);
+            });
+
+            await UpdateToLatestSchema(cancellationToken, innerProgress).ConfigureAwait(false);
+
+            innerProgress = new ActionableProgress<double>();
+            innerProgress.RegisterAction(p =>
+            {
+                double newPercentCommplete = 40 + .05 * p;
+                OnProgress(newPercentCommplete);
+                progress.Report(newPercentCommplete);
+            });
+            await CleanDeadItems(cancellationToken, innerProgress).ConfigureAwait(false);
+            progress.Report(45);
+
+            innerProgress = new ActionableProgress<double>();
+            innerProgress.RegisterAction(p =>
+            {
+                double newPercentCommplete = 45 + .55 * p;
+                OnProgress(newPercentCommplete);
+                progress.Report(newPercentCommplete);
+            });
+            await CleanDeletedItems(cancellationToken, innerProgress).ConfigureAwait(false);
+            progress.Report(100);
+
+            await _itemRepo.UpdateInheritedValues(cancellationToken).ConfigureAwait(false);
+
+            if (_config.Configuration.MigrationVersion < MigrationVersion)
+            {
+                _config.Configuration.MigrationVersion = MigrationVersion;
+                _config.SaveConfiguration();
+            }
+
+            if (_config.Configuration.SchemaVersion < LatestSchemaVersion)
+            {
+                _config.Configuration.SchemaVersion = LatestSchemaVersion;
+                _config.SaveConfiguration();
+            }
+
+            if (EnableUnavailableMessage)
+            {
+                EnableUnavailableMessage = false;
+                _httpServer.GlobalResponse = null;
+                _taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
+            }
+
+            _taskManager.SuspendTriggers = false;
+        }
+
+        private void OnProgress(double newPercentCommplete)
+        {
+            if (EnableUnavailableMessage)
+            {
+                var html = "<!doctype html><html><head><title>Emby</title></head><body>";
+                var text = _localization.GetLocalizedString("DbUpgradeMessage");
+                html += string.Format(text, newPercentCommplete.ToString("N2", CultureInfo.InvariantCulture));
+
+                html += "<script>setTimeout(function(){window.location.reload(true);}, 5000);</script>";
+                html += "</body></html>";
+
+                _httpServer.GlobalResponse = html;
+            }
+        }
+
+        private async Task UpdateToLatestSchema(CancellationToken cancellationToken, IProgress<double> progress)
+        {
+            var itemIds = _libraryManager.GetItemIds(new InternalItemsQuery
+            {
+                IsCurrentSchema = false,
+                ExcludeItemTypes = new[] { typeof(LiveTvProgram).Name }
+            });
+
+            var numComplete = 0;
+            var numItems = itemIds.Count;
+
+            _logger.Debug("Upgrading schema for {0} items", numItems);
+
+            var list = new List<BaseItem>();
+
+            foreach (var itemId in itemIds)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (itemId != Guid.Empty)
+                {
+                    // Somehow some invalid data got into the db. It probably predates the boundary checking
+                    var item = _libraryManager.GetItemById(itemId);
+
+                    if (item != null)
+                    {
+                        list.Add(item);
+                    }
+                }
+
+                if (list.Count >= 1000)
+                {
+                    try
+                    {
+                        await _itemRepo.SaveItems(list, cancellationToken).ConfigureAwait(false);
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        throw;
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.ErrorException("Error saving item", ex);
+                    }
+
+                    list.Clear();
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= numItems;
+                progress.Report(percent * 100);
+            }
+
+            if (list.Count > 0)
+            {
+                try
+                {
+                    await _itemRepo.SaveItems(list, cancellationToken).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    throw;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error saving item", ex);
+                }
+            }
+
+            progress.Report(100);
+        }
+
+        private async Task CleanDeadItems(CancellationToken cancellationToken, IProgress<double> progress)
+        {
+            var itemIds = _libraryManager.GetItemIds(new InternalItemsQuery
+            {
+                HasDeadParentId = true
+            });
+
+            var numComplete = 0;
+            var numItems = itemIds.Count;
+
+            _logger.Debug("Cleaning {0} items with dead parent links", numItems);
+
+            foreach (var itemId in itemIds)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var item = _libraryManager.GetItemById(itemId);
+
+                if (item != null)
+                {
+                    _logger.Info("Cleaning item {0} type: {1} path: {2}", item.Name, item.GetType().Name, item.Path ?? string.Empty);
+
+                    await item.Delete(new DeleteOptions
+                    {
+                        DeleteFileLocation = false
+
+                    }).ConfigureAwait(false);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= numItems;
+                progress.Report(percent * 100);
+            }
+
+            progress.Report(100);
+        }
+
+        private async Task CleanDeletedItems(CancellationToken cancellationToken, IProgress<double> progress)
+        {
+            var result = _itemRepo.GetItemIdsWithPath(new InternalItemsQuery
+            {
+                LocationTypes = new[] { LocationType.FileSystem },
+                //Limit = limit,
+
+                // These have their own cleanup routines
+                ExcludeItemTypes = new[]
+                {
+                    typeof(Person).Name,
+                    typeof(Genre).Name,
+                    typeof(MusicGenre).Name,
+                    typeof(GameGenre).Name,
+                    typeof(Studio).Name,
+                    typeof(Year).Name,
+                    typeof(Channel).Name,
+                    typeof(AggregateFolder).Name,
+                    typeof(CollectionFolder).Name
+                }
+            });
+
+            var numComplete = 0;
+            var numItems = result.Items.Length;
+
+            foreach (var item in result.Items)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                var path = item.Item2;
+
+                try
+                {
+                    if (_fileSystem.FileExists(path) || _fileSystem.DirectoryExists(path))
+                    {
+                        continue;
+                    }
+
+                    var libraryItem = _libraryManager.GetItemById(item.Item1);
+
+                    if (libraryItem.IsTopParent)
+                    {
+                        continue;
+                    }
+
+                    var hasDualAccess = libraryItem as IHasDualAccess;
+                    if (hasDualAccess != null && hasDualAccess.IsAccessedByName)
+                    {
+                        continue;
+                    }
+
+                    var libraryItemPath = libraryItem.Path;
+                    if (!string.Equals(libraryItemPath, path, StringComparison.OrdinalIgnoreCase))
+                    {
+                        _logger.Error("CleanDeletedItems aborting delete for item {0}-{1} because paths don't match. {2}---{3}", libraryItem.Id, libraryItem.Name, libraryItem.Path ?? string.Empty, path ?? string.Empty);
+                        continue;
+                    }
+
+                    if (Folder.IsPathOffline(path))
+                    {
+                        await libraryItem.UpdateIsOffline(true).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    _logger.Info("Deleting item from database {0} because path no longer exists. type: {1} path: {2}", libraryItem.Name, libraryItem.GetType().Name, libraryItemPath ?? string.Empty);
+
+                    await libraryItem.OnFileDeleted().ConfigureAwait(false);
+                }
+                catch (OperationCanceledException)
+                {
+                    throw;
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error in CleanDeletedItems. File {0}", ex, path);
+                }
+
+                numComplete++;
+                double percent = numComplete;
+                percent /= numItems;
+                progress.Report(percent * 100);
+            }
+        }
+
+        /// <summary>
+        /// Creates the triggers that define when the task will run
+        /// </summary>
+        /// <returns>IEnumerable{BaseTaskTrigger}.</returns>
+        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
+        {
+            return new[] { 
+            
+                // Every so often
+                new TaskTriggerInfo { Type = TaskTriggerInfo.TriggerInterval, IntervalTicks = TimeSpan.FromHours(24).Ticks}
+            };
+        }
+
+        public string Key
+        {
+            get { return "CleanDatabase"; }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Emby.Server.Implementations/Data/SqliteExtensions.cs b/Emby.Server.Implementations/Data/SqliteExtensions.cs
new file mode 100644
index 000000000..62615c669
--- /dev/null
+++ b/Emby.Server.Implementations/Data/SqliteExtensions.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Globalization;
+using SQLitePCL.pretty;
+
+namespace Emby.Server.Implementations.Data
+{
+    public static class SqliteExtensions
+    {
+        public static void RunQueries(this SQLiteDatabaseConnection connection, string[] queries)
+        {
+            if (queries == null)
+            {
+                throw new ArgumentNullException("queries");
+            }
+
+            connection.RunInTransaction(conn =>
+            {
+                //foreach (var query in queries)
+                //{
+                //    conn.Execute(query);
+                //}
+                conn.ExecuteAll(string.Join(";", queries));
+            });
+        }
+
+        public static byte[] ToGuidParamValue(this string str)
+        {
+            return new Guid(str).ToByteArray();
+        }
+
+        public static Guid ReadGuid(this IResultSetValue result)
+        {
+            return new Guid(result.ToBlob());
+        }
+
+        public static string ToDateTimeParamValue(this DateTime dateValue)
+        {
+            var kind = DateTimeKind.Utc;
+
+            return (dateValue.Kind == DateTimeKind.Unspecified)
+                ? DateTime.SpecifyKind(dateValue, kind).ToString(
+                    GetDateTimeKindFormat(kind),
+                    CultureInfo.InvariantCulture)
+                : dateValue.ToString(
+                    GetDateTimeKindFormat(dateValue.Kind),
+                    CultureInfo.InvariantCulture);
+        }
+
+        private static string GetDateTimeKindFormat(
+           DateTimeKind kind)
+        {
+            return (kind == DateTimeKind.Utc) ? _datetimeFormatUtc : _datetimeFormatLocal;
+        }
+
+        /// <summary>
+        /// An array of ISO-8601 DateTime formats that we support parsing.
+        /// </summary>
+        private static string[] _datetimeFormats = new string[] {
+      "THHmmssK",
+      "THHmmK",
+      "HH:mm:ss.FFFFFFFK",
+      "HH:mm:ssK",
+      "HH:mmK",
+      "yyyy-MM-dd HH:mm:ss.FFFFFFFK", /* NOTE: UTC default (5). */
+      "yyyy-MM-dd HH:mm:ssK",
+      "yyyy-MM-dd HH:mmK",
+      "yyyy-MM-ddTHH:mm:ss.FFFFFFFK",
+      "yyyy-MM-ddTHH:mmK",
+      "yyyy-MM-ddTHH:mm:ssK",
+      "yyyyMMddHHmmssK",
+      "yyyyMMddHHmmK",
+      "yyyyMMddTHHmmssFFFFFFFK",
+      "THHmmss",
+      "THHmm",
+      "HH:mm:ss.FFFFFFF",
+      "HH:mm:ss",
+      "HH:mm",
+      "yyyy-MM-dd HH:mm:ss.FFFFFFF", /* NOTE: Non-UTC default (19). */
+      "yyyy-MM-dd HH:mm:ss",
+      "yyyy-MM-dd HH:mm",
+      "yyyy-MM-ddTHH:mm:ss.FFFFFFF",
+      "yyyy-MM-ddTHH:mm",
+      "yyyy-MM-ddTHH:mm:ss",
+      "yyyyMMddHHmmss",
+      "yyyyMMddHHmm",
+      "yyyyMMddTHHmmssFFFFFFF",
+      "yyyy-MM-dd",
+      "yyyyMMdd",
+      "yy-MM-dd"
+    };
+
+        private static string _datetimeFormatUtc = _datetimeFormats[5];
+        private static string _datetimeFormatLocal = _datetimeFormats[19];
+
+        public static DateTime ReadDateTime(this IResultSetValue result)
+        {
+            var dateText = result.ToString();
+
+            return DateTime.ParseExact(
+                dateText, _datetimeFormats,
+                DateTimeFormatInfo.InvariantInfo,
+                DateTimeStyles.None).ToUniversalTime();
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Devices/DeviceRepository.cs b/Emby.Server.Implementations/Devices/DeviceRepository.cs
new file mode 100644
index 000000000..f739765b3
--- /dev/null
+++ b/Emby.Server.Implementations/Devices/DeviceRepository.cs
@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller.Devices;
+using MediaBrowser.Model.Devices;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Serialization;
+using MediaBrowser.Model.Session;
+
+namespace Emby.Server.Implementations.Devices
+{
+    public class DeviceRepository : IDeviceRepository
+    {
+        private readonly object _syncLock = new object();
+
+        private readonly IApplicationPaths _appPaths;
+        private readonly IJsonSerializer _json;
+        private readonly ILogger _logger;
+        private readonly IFileSystem _fileSystem;
+
+        private Dictionary<string, DeviceInfo> _devices;
+
+        public DeviceRepository(IApplicationPaths appPaths, IJsonSerializer json, ILogger logger, IFileSystem fileSystem)
+        {
+            _appPaths = appPaths;
+            _json = json;
+            _logger = logger;
+            _fileSystem = fileSystem;
+        }
+
+        private string GetDevicesPath()
+        {
+            return Path.Combine(_appPaths.DataPath, "devices");
+        }
+
+        private string GetDevicePath(string id)
+        {
+            return Path.Combine(GetDevicesPath(), id.GetMD5().ToString("N"));
+        }
+
+        public Task SaveDevice(DeviceInfo device)
+        {
+            var path = Path.Combine(GetDevicePath(device.Id), "device.json");
+            _fileSystem.CreateDirectory(Path.GetDirectoryName(path));
+
+            lock (_syncLock)
+            {
+                _json.SerializeToFile(device, path);
+                _devices[device.Id] = device;
+            }
+            return Task.FromResult(true);
+        }
+
+        public Task SaveCapabilities(string reportedId, ClientCapabilities capabilities)
+        {
+            var device = GetDevice(reportedId);
+
+            if (device == null)
+            {
+                throw new ArgumentException("No device has been registed with id " + reportedId);
+            }
+
+            device.Capabilities = capabilities;
+            SaveDevice(device);
+
+            return Task.FromResult(true);
+        }
+
+        public ClientCapabilities GetCapabilities(string reportedId)
+        {
+            var device = GetDevice(reportedId);
+
+            return device == null ? null : device.Capabilities;
+        }
+
+        public DeviceInfo GetDevice(string id)
+        {
+            if (string.IsNullOrWhiteSpace(id))
+            {
+                throw new ArgumentNullException("id");
+            }
+
+            return GetDevices()
+                .FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
+        }
+
+        public IEnumerable<DeviceInfo> GetDevices()
+        {
+            lock (_syncLock)
+            {
+                if (_devices == null)
+                {
+                    _devices = new Dictionary<string, DeviceInfo>(StringComparer.OrdinalIgnoreCase);
+
+                    var devices = LoadDevices().ToList();
+                    foreach (var device in devices)
+                    {
+                        _devices[device.Id] = device;
+                    }
+                }
+                return _devices.Values.ToList();
+            }
+        }
+
+        private IEnumerable<DeviceInfo> LoadDevices()
+        {
+            var path = GetDevicesPath();
+
+            try
+            {
+                return _fileSystem
+                    .GetFilePaths(path, true)
+                    .Where(i => string.Equals(Path.GetFileName(i), "device.json", StringComparison.OrdinalIgnoreCase))
+                    .ToList()
+                    .Select(i =>
+                    {
+                        try
+                        {
+                            return _json.DeserializeFromFile<DeviceInfo>(i);
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.ErrorException("Error reading {0}", ex, i);
+                            return null;
+                        }
+                    })
+                    .Where(i => i != null);
+            }
+            catch (IOException)
+            {
+                return new List<DeviceInfo>();
+            }
+        }
+
+        public Task DeleteDevice(string id)
+        {
+            var path = GetDevicePath(id);
+
+            lock (_syncLock)
+            {
+                try
+                {
+                    _fileSystem.DeleteDirectory(path, true);
+                }
+                catch (IOException)
+                {
+                }
+
+                _devices = null;
+            }
+
+            return Task.FromResult(true);
+        }
+
+        public ContentUploadHistory GetCameraUploadHistory(string deviceId)
+        {
+            var path = Path.Combine(GetDevicePath(deviceId), "camerauploads.json");
+
+            lock (_syncLock)
+            {
+                try
+                {
+                    return _json.DeserializeFromFile<ContentUploadHistory>(path);
+                }
+                catch (IOException)
+                {
+                    return new ContentUploadHistory
+                    {
+                        DeviceId = deviceId
+                    };
+                }
+            }
+        }
+
+        public void AddCameraUpload(string deviceId, LocalFileInfo file)
+        {
+            var path = Path.Combine(GetDevicePath(deviceId), "camerauploads.json");
+            _fileSystem.CreateDirectory(Path.GetDirectoryName(path));
+
+            lock (_syncLock)
+            {
+                ContentUploadHistory history;
+
+                try
+                {
+                    history = _json.DeserializeFromFile<ContentUploadHistory>(path);
+                }
+                catch (IOException)
+                {
+                    history = new ContentUploadHistory
+                    {
+                        DeviceId = deviceId
+                    };
+                }
+
+                history.DeviceId = deviceId;
+                history.FilesUploaded.Add(file);
+
+                _json.SerializeToFile(history, path);
+            }
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Emby.Server.Implementations.csproj b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
index 13d184b59..6843ad9d7 100644
--- a/Emby.Server.Implementations/Emby.Server.Implementations.csproj
+++ b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
@@ -34,6 +34,7 @@
   <ItemGroup>
     <Compile Include="Activity\ActivityLogEntryPoint.cs" />
     <Compile Include="Activity\ActivityManager.cs" />
+    <Compile Include="Activity\ActivityRepository.cs" />
     <Compile Include="Branding\BrandingConfigurationFactory.cs" />
     <Compile Include="Channels\ChannelConfigurations.cs" />
     <Compile Include="Channels\ChannelDynamicMediaSourceProvider.cs" />
@@ -51,6 +52,7 @@
     <Compile Include="Connect\Validator.cs" />
     <Compile Include="Devices\CameraUploadsDynamicFolder.cs" />
     <Compile Include="Devices\DeviceManager.cs" />
+    <Compile Include="Devices\DeviceRepository.cs" />
     <Compile Include="Dto\DtoService.cs" />
     <Compile Include="EntryPoints\AutomaticRestartEntryPoint.cs" />
     <Compile Include="EntryPoints\KeepServerAwake.cs" />
@@ -165,6 +167,7 @@
     <Compile Include="LiveTv\TunerHosts\QueueStream.cs" />
     <Compile Include="Localization\LocalizationManager.cs" />
     <Compile Include="MediaEncoder\EncodingManager.cs" />
+    <Compile Include="Migrations\IVersionMigration.cs" />
     <Compile Include="News\NewsEntryPoint.cs" />
     <Compile Include="News\NewsService.cs" />
     <Compile Include="Notifications\CoreNotificationTypes.cs" />
@@ -173,8 +176,11 @@
     <Compile Include="Notifications\NotificationConfigurationFactory.cs" />
     <Compile Include="Notifications\NotificationManager.cs" />
     <Compile Include="Notifications\Notifications.cs" />
+    <Compile Include="Notifications\SqliteNotificationsRepository.cs" />
     <Compile Include="Notifications\WebSocketNotifier.cs" />
-    <Compile Include="Persistence\CleanDatabaseScheduledTask.cs" />
+    <Compile Include="Data\BaseSqliteRepository.cs" />
+    <Compile Include="Data\CleanDatabaseScheduledTask.cs" />
+    <Compile Include="Data\SqliteExtensions.cs" />
     <Compile Include="Photos\PhotoAlbumImageProvider.cs" />
     <Compile Include="Playlists\PlaylistImageProvider.cs" />
     <Compile Include="Playlists\PlaylistManager.cs" />
@@ -197,6 +203,7 @@
     <Compile Include="Session\SessionWebSocketListener.cs" />
     <Compile Include="Session\WebSocketController.cs" />
     <Compile Include="Social\SharingManager.cs" />
+    <Compile Include="Social\SharingRepository.cs" />
     <Compile Include="Sorting\AiredEpisodeOrderComparer.cs" />
     <Compile Include="Sorting\AirTimeComparer.cs" />
     <Compile Include="Sorting\AlbumArtistComparer.cs" />
@@ -291,6 +298,14 @@
       <HintPath>..\packages\MediaBrowser.Naming.1.0.2\lib\portable-net45+win8\MediaBrowser.Naming.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="SQLitePCL.pretty, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\packages\SQLitePCL.pretty.1.1.0\lib\portable-net45+netcore45+wpa81+wp8\SQLitePCL.pretty.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="SQLitePCLRaw.core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1488e028ca7ab535, processorArchitecture=MSIL">
+      <HintPath>..\packages\SQLitePCLRaw.core.1.1.0\lib\portable-net45+netcore45+wpa81+MonoAndroid10+MonoTouch10+Xamarin.iOS10\SQLitePCLRaw.core.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="UniversalDetector, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\packages\UniversalDetector.1.0.1\lib\portable-net45+sl4+wp71+win8+wpa81\UniversalDetector.dll</HintPath>
       <Private>True</Private>
diff --git a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
index c32af8eb1..6cd24058a 100644
--- a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
@@ -127,7 +127,11 @@ namespace Emby.Server.Implementations.Library.Validators
                 {
                     var item = _libraryManager.GetPerson(person.Key);
 
-                    var options = new MetadataRefreshOptions(_fileSystem);
+                    var options = new MetadataRefreshOptions(_fileSystem)
+                    {
+                        ImageRefreshMode = ImageRefreshMode.ValidationOnly,
+                        MetadataRefreshMode = MetadataRefreshMode.ValidationOnly
+                    };
 
                     await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
                 }
diff --git a/Emby.Server.Implementations/Migrations/IVersionMigration.cs b/Emby.Server.Implementations/Migrations/IVersionMigration.cs
new file mode 100644
index 000000000..7804912e3
--- /dev/null
+++ b/Emby.Server.Implementations/Migrations/IVersionMigration.cs
@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace Emby.Server.Implementations.Migrations
+{
+    public interface IVersionMigration
+    {
+        Task Run();
+    }
+}
diff --git a/Emby.Server.Implementations/Notifications/SqliteNotificationsRepository.cs b/Emby.Server.Implementations/Notifications/SqliteNotificationsRepository.cs
new file mode 100644
index 000000000..fcf45b0ad
--- /dev/null
+++ b/Emby.Server.Implementations/Notifications/SqliteNotificationsRepository.cs
@@ -0,0 +1,309 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Emby.Server.Implementations.Data;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Notifications;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Notifications;
+using SQLitePCL.pretty;
+
+namespace Emby.Server.Implementations.Notifications
+{
+    public class SqliteNotificationsRepository : BaseSqliteRepository, INotificationsRepository
+    {
+        public SqliteNotificationsRepository(ILogger logger, IServerApplicationPaths appPaths) : base(logger)
+        {
+            DbFilePath = Path.Combine(appPaths.DataPath, "notifications.db");
+        }
+
+        public event EventHandler<NotificationUpdateEventArgs> NotificationAdded;
+        public event EventHandler<NotificationReadEventArgs> NotificationsMarkedRead;
+        ////public event EventHandler<NotificationUpdateEventArgs> NotificationUpdated;
+
+        public void Initialize()
+        {
+            using (var connection = CreateConnection())
+            {
+                string[] queries = {
+                                "create table if not exists Notifications (Id GUID NOT NULL, UserId GUID NOT NULL, Date DATETIME NOT NULL, Name TEXT NOT NULL, Description TEXT NULL, Url TEXT NULL, Level TEXT NOT NULL, IsRead BOOLEAN NOT NULL, Category TEXT NOT NULL, RelatedId TEXT NULL, PRIMARY KEY (Id, UserId))",
+                                "create index if not exists idx_Notifications1 on Notifications(Id)",
+                                "create index if not exists idx_Notifications2 on Notifications(UserId)"
+                               };
+
+                connection.RunQueries(queries);
+            }
+        }
+
+        /// <summary>
+        /// Gets the notifications.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>NotificationResult.</returns>
+        public NotificationResult GetNotifications(NotificationQuery query)
+        {
+            var result = new NotificationResult();
+
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection(true))
+                {
+                    var clauses = new List<string>();
+                    var paramList = new List<object>();
+
+                    if (query.IsRead.HasValue)
+                    {
+                        clauses.Add("IsRead=?");
+                        paramList.Add(query.IsRead.Value);
+                    }
+
+                    clauses.Add("UserId=?");
+                    paramList.Add(query.UserId.ToGuidParamValue());
+
+                    var whereClause = " where " + string.Join(" And ", clauses.ToArray());
+
+                    result.TotalRecordCount = connection.Query("select count(Id) from Notifications" + whereClause, paramList.ToArray()).SelectScalarInt().First();
+
+                    var commandText = string.Format("select Id,UserId,Date,Name,Description,Url,Level,IsRead,Category,RelatedId from Notifications{0} order by IsRead asc, Date desc", whereClause);
+
+                    if (query.Limit.HasValue || query.StartIndex.HasValue)
+                    {
+                        var offset = query.StartIndex ?? 0;
+
+                        if (query.Limit.HasValue || offset > 0)
+                        {
+                            commandText += " LIMIT " + (query.Limit ?? int.MaxValue).ToString(CultureInfo.InvariantCulture);
+                        }
+
+                        if (offset > 0)
+                        {
+                            commandText += " OFFSET " + offset.ToString(CultureInfo.InvariantCulture);
+                        }
+                    }
+
+                    var resultList = new List<Notification>();
+
+                    foreach (var row in connection.Query(commandText, paramList.ToArray()))
+                    {
+                        resultList.Add(GetNotification(row));
+                    }
+
+                    result.Notifications = resultList.ToArray();
+                }
+            }
+
+            return result;
+        }
+
+        public NotificationsSummary GetNotificationsSummary(string userId)
+        {
+            var result = new NotificationsSummary();
+
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection(true))
+                {
+                    foreach (var row in connection.Query("select Level from Notifications where UserId=? and IsRead=?", userId.ToGuidParamValue(), false))
+                    {
+                        var levels = new List<NotificationLevel>();
+
+                        levels.Add(GetLevel(row, 0));
+
+                        result.UnreadCount = levels.Count;
+
+                        if (levels.Count > 0)
+                        {
+                            result.MaxUnreadNotificationLevel = levels.Max();
+                        }
+                    }
+
+                    return result;
+                }
+            }
+        }
+
+        private Notification GetNotification(IReadOnlyList<IResultSetValue> reader)
+        {
+            var notification = new Notification
+            {
+                Id = reader[0].ReadGuid().ToString("N"),
+                UserId = reader[1].ReadGuid().ToString("N"),
+                Date = reader[2].ReadDateTime(),
+                Name = reader[3].ToString()
+            };
+
+            if (reader[4].SQLiteType != SQLiteType.Null)
+            {
+                notification.Description = reader[4].ToString();
+            }
+
+            if (reader[5].SQLiteType != SQLiteType.Null)
+            {
+                notification.Url = reader[5].ToString();
+            }
+
+            notification.Level = GetLevel(reader, 6);
+            notification.IsRead = reader[7].ToBool();
+
+            return notification;
+        }
+
+        /// <summary>
+        /// Gets the level.
+        /// </summary>
+        /// <param name="reader">The reader.</param>
+        /// <param name="index">The index.</param>
+        /// <returns>NotificationLevel.</returns>
+        private NotificationLevel GetLevel(IReadOnlyList<IResultSetValue> reader, int index)
+        {
+            NotificationLevel level;
+
+            var val = reader[index].ToString();
+
+            Enum.TryParse(val, true, out level);
+
+            return level;
+        }
+
+        /// <summary>
+        /// Adds the notification.
+        /// </summary>
+        /// <param name="notification">The notification.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public async Task AddNotification(Notification notification, CancellationToken cancellationToken)
+        {
+            await ReplaceNotification(notification, cancellationToken).ConfigureAwait(false);
+
+            if (NotificationAdded != null)
+            {
+                try
+                {
+                    NotificationAdded(this, new NotificationUpdateEventArgs
+                    {
+                        Notification = notification
+                    });
+                }
+                catch (Exception ex)
+                {
+                    Logger.ErrorException("Error in NotificationAdded event handler", ex);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Replaces the notification.
+        /// </summary>
+        /// <param name="notification">The notification.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        private async Task ReplaceNotification(Notification notification, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrEmpty(notification.Id))
+            {
+                notification.Id = Guid.NewGuid().ToString("N");
+            }
+            if (string.IsNullOrEmpty(notification.UserId))
+            {
+                throw new ArgumentException("The notification must have a user id");
+            }
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection())
+                {
+                    connection.RunInTransaction(conn =>
+                    {
+                        conn.Execute("replace into Notifications (Id, UserId, Date, Name, Description, Url, Level, IsRead, Category, RelatedId) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                            notification.Id.ToGuidParamValue(),
+                            notification.UserId.ToGuidParamValue(),
+                            notification.Date.ToDateTimeParamValue(),
+                            notification.Name,
+                            notification.Description,
+                            notification.Url,
+                            notification.Level.ToString(),
+                            notification.IsRead,
+                            string.Empty,
+                            string.Empty);
+                    });
+                }
+            }
+        }
+
+        /// <summary>
+        /// Marks the read.
+        /// </summary>
+        /// <param name="notificationIdList">The notification id list.</param>
+        /// <param name="userId">The user id.</param>
+        /// <param name="isRead">if set to <c>true</c> [is read].</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>Task.</returns>
+        public async Task MarkRead(IEnumerable<string> notificationIdList, string userId, bool isRead, CancellationToken cancellationToken)
+        {
+            var list = notificationIdList.ToList();
+            var idArray = list.Select(i => new Guid(i)).ToArray();
+
+            await MarkReadInternal(idArray, userId, isRead, cancellationToken).ConfigureAwait(false);
+
+            if (NotificationsMarkedRead != null)
+            {
+                try
+                {
+                    NotificationsMarkedRead(this, new NotificationReadEventArgs
+                    {
+                        IdList = list.ToArray(),
+                        IsRead = isRead,
+                        UserId = userId
+                    });
+                }
+                catch (Exception ex)
+                {
+                    Logger.ErrorException("Error in NotificationsMarkedRead event handler", ex);
+                }
+            }
+        }
+
+        public async Task MarkAllRead(string userId, bool isRead, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection())
+                {
+                    connection.RunInTransaction(conn =>
+                    {
+                        conn.Execute("update Notifications set IsRead=? where UserId=?", userId.ToGuidParamValue(), isRead);
+                    });
+                }
+            }
+        }
+
+        private async Task MarkReadInternal(IEnumerable<Guid> notificationIdList, string userId, bool isRead, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection())
+                {
+                    connection.RunInTransaction(conn =>
+                    {
+                        var userIdParam = userId.ToGuidParamValue();
+
+                        foreach (var id in notificationIdList)
+                        {
+                            conn.Execute("update Notifications set IsRead=? where UserId=? and Id=?", userIdParam, isRead, id);
+                        }
+                    });
+                }
+            }
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/Persistence/CleanDatabaseScheduledTask.cs b/Emby.Server.Implementations/Persistence/CleanDatabaseScheduledTask.cs
deleted file mode 100644
index 88f4f1f81..000000000
--- a/Emby.Server.Implementations/Persistence/CleanDatabaseScheduledTask.cs
+++ /dev/null
@@ -1,361 +0,0 @@
-using MediaBrowser.Common.Progress;
-using MediaBrowser.Controller.Configuration;
-using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Library;
-using MediaBrowser.Controller.Persistence;
-using MediaBrowser.Model.Entities;
-using MediaBrowser.Model.Logging;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using MediaBrowser.Common.IO;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Controller.Channels;
-using MediaBrowser.Controller.Entities.Audio;
-using MediaBrowser.Controller.IO;
-using MediaBrowser.Controller.LiveTv;
-using MediaBrowser.Controller.Net;
-using MediaBrowser.Model.Globalization;
-using MediaBrowser.Model.Tasks;
-using Emby.Server.Implementations.ScheduledTasks;
-
-namespace Emby.Server.Implementations.Persistence
-{
-    public class CleanDatabaseScheduledTask : IScheduledTask
-    {
-        private readonly ILibraryManager _libraryManager;
-        private readonly IItemRepository _itemRepo;
-        private readonly ILogger _logger;
-        private readonly IServerConfigurationManager _config;
-        private readonly IFileSystem _fileSystem;
-        private readonly IHttpServer _httpServer;
-        private readonly ILocalizationManager _localization;
-        private readonly ITaskManager _taskManager;
-
-        public const int MigrationVersion = 23;
-        public static bool EnableUnavailableMessage = false;
-        const int LatestSchemaVersion = 109;
-
-        public CleanDatabaseScheduledTask(ILibraryManager libraryManager, IItemRepository itemRepo, ILogger logger, IServerConfigurationManager config, IFileSystem fileSystem, IHttpServer httpServer, ILocalizationManager localization, ITaskManager taskManager)
-        {
-            _libraryManager = libraryManager;
-            _itemRepo = itemRepo;
-            _logger = logger;
-            _config = config;
-            _fileSystem = fileSystem;
-            _httpServer = httpServer;
-            _localization = localization;
-            _taskManager = taskManager;
-        }
-
-        public string Name
-        {
-            get { return "Clean Database"; }
-        }
-
-        public string Description
-        {
-            get { return "Deletes obsolete content from the database."; }
-        }
-
-        public string Category
-        {
-            get { return "Library"; }
-        }
-
-        public async Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
-        {
-            OnProgress(0);
-
-            // Ensure these objects are lazy loaded.
-            // Without this there is a deadlock that will need to be investigated
-            var rootChildren = _libraryManager.RootFolder.Children.ToList();
-            rootChildren = _libraryManager.GetUserRootFolder().Children.ToList();
-
-            var innerProgress = new ActionableProgress<double>();
-            innerProgress.RegisterAction(p =>
-            {
-                double newPercentCommplete = .4 * p;
-                OnProgress(newPercentCommplete);
-
-                progress.Report(newPercentCommplete);
-            });
-
-            await UpdateToLatestSchema(cancellationToken, innerProgress).ConfigureAwait(false);
-
-            innerProgress = new ActionableProgress<double>();
-            innerProgress.RegisterAction(p =>
-            {
-                double newPercentCommplete = 40 + .05 * p;
-                OnProgress(newPercentCommplete);
-                progress.Report(newPercentCommplete);
-            });
-            await CleanDeadItems(cancellationToken, innerProgress).ConfigureAwait(false);
-            progress.Report(45);
-
-            innerProgress = new ActionableProgress<double>();
-            innerProgress.RegisterAction(p =>
-            {
-                double newPercentCommplete = 45 + .55 * p;
-                OnProgress(newPercentCommplete);
-                progress.Report(newPercentCommplete);
-            });
-            await CleanDeletedItems(cancellationToken, innerProgress).ConfigureAwait(false);
-            progress.Report(100);
-
-            await _itemRepo.UpdateInheritedValues(cancellationToken).ConfigureAwait(false);
-
-            if (_config.Configuration.MigrationVersion < MigrationVersion)
-            {
-                _config.Configuration.MigrationVersion = MigrationVersion;
-                _config.SaveConfiguration();
-            }
-
-            if (_config.Configuration.SchemaVersion < LatestSchemaVersion)
-            {
-                _config.Configuration.SchemaVersion = LatestSchemaVersion;
-                _config.SaveConfiguration();
-            }
-
-            if (EnableUnavailableMessage)
-            {
-                EnableUnavailableMessage = false;
-                _httpServer.GlobalResponse = null;
-                _taskManager.QueueScheduledTask<RefreshMediaLibraryTask>();
-            }
-
-            _taskManager.SuspendTriggers = false;
-        }
-
-        private void OnProgress(double newPercentCommplete)
-        {
-            if (EnableUnavailableMessage)
-            {
-                var html = "<!doctype html><html><head><title>Emby</title></head><body>";
-                var text = _localization.GetLocalizedString("DbUpgradeMessage");
-                html += string.Format(text, newPercentCommplete.ToString("N2", CultureInfo.InvariantCulture));
-
-                html += "<script>setTimeout(function(){window.location.reload(true);}, 5000);</script>";
-                html += "</body></html>";
-
-                _httpServer.GlobalResponse = html;
-            }
-        }
-
-        private async Task UpdateToLatestSchema(CancellationToken cancellationToken, IProgress<double> progress)
-        {
-            var itemIds = _libraryManager.GetItemIds(new InternalItemsQuery
-            {
-                IsCurrentSchema = false,
-                ExcludeItemTypes = new[] { typeof(LiveTvProgram).Name }
-            });
-
-            var numComplete = 0;
-            var numItems = itemIds.Count;
-
-            _logger.Debug("Upgrading schema for {0} items", numItems);
-
-            var list = new List<BaseItem>();
-
-            foreach (var itemId in itemIds)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                if (itemId != Guid.Empty)
-                {
-                    // Somehow some invalid data got into the db. It probably predates the boundary checking
-                    var item = _libraryManager.GetItemById(itemId);
-
-                    if (item != null)
-                    {
-                        list.Add(item);
-                    }
-                }
-
-                if (list.Count >= 1000)
-                {
-                    try
-                    {
-                        await _itemRepo.SaveItems(list, cancellationToken).ConfigureAwait(false);
-                    }
-                    catch (OperationCanceledException)
-                    {
-                        throw;
-                    }
-                    catch (Exception ex)
-                    {
-                        _logger.ErrorException("Error saving item", ex);
-                    }
-
-                    list.Clear();
-                }
-
-                numComplete++;
-                double percent = numComplete;
-                percent /= numItems;
-                progress.Report(percent * 100);
-            }
-
-            if (list.Count > 0)
-            {
-                try
-                {
-                    await _itemRepo.SaveItems(list, cancellationToken).ConfigureAwait(false);
-                }
-                catch (OperationCanceledException)
-                {
-                    throw;
-                }
-                catch (Exception ex)
-                {
-                    _logger.ErrorException("Error saving item", ex);
-                }
-            }
-
-            progress.Report(100);
-        }
-
-        private async Task CleanDeadItems(CancellationToken cancellationToken, IProgress<double> progress)
-        {
-            var itemIds = _libraryManager.GetItemIds(new InternalItemsQuery
-            {
-                HasDeadParentId = true
-            });
-
-            var numComplete = 0;
-            var numItems = itemIds.Count;
-
-            _logger.Debug("Cleaning {0} items with dead parent links", numItems);
-
-            foreach (var itemId in itemIds)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                var item = _libraryManager.GetItemById(itemId);
-
-                if (item != null)
-                {
-                    _logger.Info("Cleaning item {0} type: {1} path: {2}", item.Name, item.GetType().Name, item.Path ?? string.Empty);
-
-                    await item.Delete(new DeleteOptions
-                    {
-                        DeleteFileLocation = false
-
-                    }).ConfigureAwait(false);
-                }
-
-                numComplete++;
-                double percent = numComplete;
-                percent /= numItems;
-                progress.Report(percent * 100);
-            }
-
-            progress.Report(100);
-        }
-
-        private async Task CleanDeletedItems(CancellationToken cancellationToken, IProgress<double> progress)
-        {
-            var result = _itemRepo.GetItemIdsWithPath(new InternalItemsQuery
-            {
-                LocationTypes = new[] { LocationType.FileSystem },
-                //Limit = limit,
-
-                // These have their own cleanup routines
-                ExcludeItemTypes = new[]
-                {
-                    typeof(Person).Name,
-                    typeof(Genre).Name,
-                    typeof(MusicGenre).Name,
-                    typeof(GameGenre).Name,
-                    typeof(Studio).Name,
-                    typeof(Year).Name,
-                    typeof(Channel).Name,
-                    typeof(AggregateFolder).Name,
-                    typeof(CollectionFolder).Name
-                }
-            });
-
-            var numComplete = 0;
-            var numItems = result.Items.Length;
-
-            foreach (var item in result.Items)
-            {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                var path = item.Item2;
-
-                try
-                {
-                    if (_fileSystem.FileExists(path) || _fileSystem.DirectoryExists(path))
-                    {
-                        continue;
-                    }
-
-                    var libraryItem = _libraryManager.GetItemById(item.Item1);
-
-                    if (libraryItem.IsTopParent)
-                    {
-                        continue;
-                    }
-
-                    var hasDualAccess = libraryItem as IHasDualAccess;
-                    if (hasDualAccess != null && hasDualAccess.IsAccessedByName)
-                    {
-                        continue;
-                    }
-
-                    var libraryItemPath = libraryItem.Path;
-                    if (!string.Equals(libraryItemPath, path, StringComparison.OrdinalIgnoreCase))
-                    {
-                        _logger.Error("CleanDeletedItems aborting delete for item {0}-{1} because paths don't match. {2}---{3}", libraryItem.Id, libraryItem.Name, libraryItem.Path ?? string.Empty, path ?? string.Empty);
-                        continue;
-                    }
-
-                    if (Folder.IsPathOffline(path))
-                    {
-                        await libraryItem.UpdateIsOffline(true).ConfigureAwait(false);
-                        continue;
-                    }
-
-                    _logger.Info("Deleting item from database {0} because path no longer exists. type: {1} path: {2}", libraryItem.Name, libraryItem.GetType().Name, libraryItemPath ?? string.Empty);
-
-                    await libraryItem.OnFileDeleted().ConfigureAwait(false);
-                }
-                catch (OperationCanceledException)
-                {
-                    throw;
-                }
-                catch (Exception ex)
-                {
-                    _logger.ErrorException("Error in CleanDeletedItems. File {0}", ex, path);
-                }
-
-                numComplete++;
-                double percent = numComplete;
-                percent /= numItems;
-                progress.Report(percent * 100);
-            }
-        }
-
-        /// <summary>
-        /// Creates the triggers that define when the task will run
-        /// </summary>
-        /// <returns>IEnumerable{BaseTaskTrigger}.</returns>
-        public IEnumerable<TaskTriggerInfo> GetDefaultTriggers()
-        {
-            return new[] { 
-            
-                // Every so often
-                new TaskTriggerInfo { Type = TaskTriggerInfo.TriggerInterval, IntervalTicks = TimeSpan.FromHours(24).Ticks}
-            };
-        }
-
-        public string Key
-        {
-            get { return "CleanDatabase"; }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Emby.Server.Implementations/Social/SharingRepository.cs b/Emby.Server.Implementations/Social/SharingRepository.cs
new file mode 100644
index 000000000..e09b7f5b9
--- /dev/null
+++ b/Emby.Server.Implementations/Social/SharingRepository.cs
@@ -0,0 +1,114 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Emby.Server.Implementations.Data;
+using MediaBrowser.Common.Configuration;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Social;
+using SQLitePCL.pretty;
+
+namespace Emby.Server.Implementations.Social
+{
+    public class SharingRepository : BaseSqliteRepository, ISharingRepository
+    {
+        public SharingRepository(ILogger logger, IApplicationPaths appPaths)
+            : base(logger)
+        {
+            DbFilePath = Path.Combine(appPaths.DataPath, "shares.db");
+        }
+
+        /// <summary>
+        /// Opens the connection to the database
+        /// </summary>
+        /// <returns>Task.</returns>
+        public void Initialize()
+        {
+            using (var connection = CreateConnection())
+            {
+                string[] queries = {
+
+                                "create table if not exists Shares (Id GUID, ItemId TEXT, UserId TEXT, ExpirationDate DateTime, PRIMARY KEY (Id))",
+                                "create index if not exists idx_Shares on Shares(Id)",
+
+                                "pragma shrink_memory"
+                               };
+
+                connection.RunQueries(queries);
+            }
+        }
+
+        public async Task CreateShare(SocialShareInfo info)
+        {
+            if (info == null)
+            {
+                throw new ArgumentNullException("info");
+            }
+            if (string.IsNullOrWhiteSpace(info.Id))
+            {
+                throw new ArgumentNullException("info.Id");
+            }
+
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection())
+                {
+                    connection.RunInTransaction(db =>
+                    {
+                        var commandText = "replace into Shares (Id, ItemId, UserId, ExpirationDate) values (?, ?, ?, ?)";
+
+                        db.Execute(commandText,
+                            info.Id.ToGuidParamValue(),
+                            info.ItemId,
+                            info.UserId,
+                            info.ExpirationDate.ToDateTimeParamValue());
+                    });
+                }
+            }
+        }
+
+        public SocialShareInfo GetShareInfo(string id)
+        {
+            if (string.IsNullOrWhiteSpace(id))
+            {
+                throw new ArgumentNullException("id");
+            }
+
+            lock (WriteLock)
+            {
+                using (var connection = CreateConnection(true))
+                {
+                    var commandText = "select Id, ItemId, UserId, ExpirationDate from Shares where id = ?";
+
+                    var paramList = new List<object>();
+                    paramList.Add(id.ToGuidParamValue());
+
+                    foreach (var row in connection.Query(commandText, paramList.ToArray()))
+                    {
+                        return GetSocialShareInfo(row);
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private SocialShareInfo GetSocialShareInfo(IReadOnlyList<IResultSetValue> reader)
+        {
+            var info = new SocialShareInfo();
+
+            info.Id = reader[0].ReadGuid().ToString("N");
+            info.ItemId = reader[1].ToString();
+            info.UserId = reader[2].ToString();
+            info.ExpirationDate = reader[3].ReadDateTime();
+
+            return info;
+        }
+
+        public async Task DeleteShare(string id)
+        {
+
+        }
+    }
+}
diff --git a/Emby.Server.Implementations/packages.config b/Emby.Server.Implementations/packages.config
index 71fdbffc2..519e4a0ad 100644
--- a/Emby.Server.Implementations/packages.config
+++ b/Emby.Server.Implementations/packages.config
@@ -2,5 +2,7 @@
 <packages>
   <package id="Emby.XmlTv" version="1.0.1" targetFramework="portable45-net45+win8" />
   <package id="MediaBrowser.Naming" version="1.0.2" targetFramework="portable45-net45+win8" />
+  <package id="SQLitePCL.pretty" version="1.1.0" targetFramework="portable45-net45+win8" />
+  <package id="SQLitePCLRaw.core" version="1.1.0" targetFramework="portable45-net45+win8" />
   <package id="UniversalDetector" version="1.0.1" targetFramework="portable45-net45+win8" />
 </packages>
\ No newline at end of file
diff --git a/MediaBrowser.Model/Logging/LogHelper.cs b/MediaBrowser.Model/Logging/LogHelper.cs
index 5b8090d30..cf1c02186 100644
--- a/MediaBrowser.Model/Logging/LogHelper.cs
+++ b/MediaBrowser.Model/Logging/LogHelper.cs
@@ -22,7 +22,7 @@ namespace MediaBrowser.Model.Logging
 
             var messageText = new StringBuilder();
 
-            messageText.AppendLine(exception.Message);
+            messageText.AppendLine(exception.ToString());
 
             messageText.AppendLine(exception.GetType().FullName);
 
@@ -71,7 +71,7 @@ namespace MediaBrowser.Model.Logging
         private static void AppendInnerException(StringBuilder messageText, Exception e)
         {
             messageText.AppendLine("InnerException: " + e.GetType().FullName);
-            messageText.AppendLine(e.Message);
+            messageText.AppendLine(e.ToString());
 
             LogExceptionData(messageText, e);
 
diff --git a/MediaBrowser.Server.Mono/MediaBrowser.Server.Mono.csproj b/MediaBrowser.Server.Mono/MediaBrowser.Server.Mono.csproj
index 270c43e13..b6d3c5ce6 100644
--- a/MediaBrowser.Server.Mono/MediaBrowser.Server.Mono.csproj
+++ b/MediaBrowser.Server.Mono/MediaBrowser.Server.Mono.csproj
@@ -84,6 +84,14 @@
       <HintPath>..\packages\SimpleInjector.3.2.4\lib\net45\SimpleInjector.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="SQLitePCLRaw.core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1488e028ca7ab535, processorArchitecture=MSIL">
+      <HintPath>..\packages\SQLitePCLRaw.core.1.1.0\lib\net45\SQLitePCLRaw.core.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="SQLitePCLRaw.provider.sqlite3, Version=1.0.0.0, Culture=neutral, PublicKeyToken=62684c7b4f184e3f, processorArchitecture=MSIL">
+      <HintPath>..\packages\SQLitePCLRaw.provider.sqlite3.net45.1.1.0\lib\net45\SQLitePCLRaw.provider.sqlite3.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="MediaBrowser.IsoMounting.Linux">
       <HintPath>..\ThirdParty\MediaBrowser.IsoMounting.Linux\MediaBrowser.IsoMounting.Linux.dll</HintPath>
diff --git a/MediaBrowser.Server.Mono/Program.cs b/MediaBrowser.Server.Mono/Program.cs
index f490a829a..9cc13a59e 100644
--- a/MediaBrowser.Server.Mono/Program.cs
+++ b/MediaBrowser.Server.Mono/Program.cs
@@ -34,6 +34,8 @@ namespace MediaBrowser.Server.Mono
 
         public static void Main(string[] args)
         {
+            SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_sqlite3());
+
             var applicationPath = Assembly.GetEntryAssembly().Location;
 
             var options = new StartupOptions();
diff --git a/MediaBrowser.Server.Mono/packages.config b/MediaBrowser.Server.Mono/packages.config
index 5727f4c18..028ee1e45 100644
--- a/MediaBrowser.Server.Mono/packages.config
+++ b/MediaBrowser.Server.Mono/packages.config
@@ -5,4 +5,6 @@
   <package id="ServiceStack.Text" version="4.5.4" targetFramework="net46" />
   <package id="SharpCompress" version="0.14.0" targetFramework="net46" />
   <package id="SimpleInjector" version="3.2.4" targetFramework="net46" />
+  <package id="SQLitePCLRaw.core" version="1.1.0" targetFramework="net46" />
+  <package id="SQLitePCLRaw.provider.sqlite3.net45" version="1.1.0" targetFramework="net46" />
 </packages>
\ No newline at end of file
diff --git a/MediaBrowser.ServerApplication/MainStartup.cs b/MediaBrowser.ServerApplication/MainStartup.cs
index f5e768133..328041bc3 100644
--- a/MediaBrowser.ServerApplication/MainStartup.cs
+++ b/MediaBrowser.ServerApplication/MainStartup.cs
@@ -90,6 +90,8 @@ namespace MediaBrowser.ServerApplication
 
             var success = SetDllDirectory(architecturePath);
 
+            SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_sqlite3());
+
             var appPaths = CreateApplicationPaths(ApplicationPath, IsRunningAsService);
 
             var logManager = new NlogManager(appPaths.LogDirectoryPath, "server");
diff --git a/MediaBrowser.ServerApplication/MediaBrowser.ServerApplication.csproj b/MediaBrowser.ServerApplication/MediaBrowser.ServerApplication.csproj
index 6984ff2be..e5a632d69 100644
--- a/MediaBrowser.ServerApplication/MediaBrowser.ServerApplication.csproj
+++ b/MediaBrowser.ServerApplication/MediaBrowser.ServerApplication.csproj
@@ -90,13 +90,21 @@
       <HintPath>..\packages\SimpleInjector.3.2.4\lib\net45\SimpleInjector.dll</HintPath>
       <Private>True</Private>
     </Reference>
+    <Reference Include="SQLitePCLRaw.core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=1488e028ca7ab535, processorArchitecture=MSIL">
+      <HintPath>..\packages\SQLitePCLRaw.core.1.1.0\lib\net45\SQLitePCLRaw.core.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="SQLitePCLRaw.provider.sqlite3, Version=1.0.0.0, Culture=neutral, PublicKeyToken=62684c7b4f184e3f, processorArchitecture=MSIL">
+      <HintPath>..\packages\SQLitePCLRaw.provider.sqlite3.net45.1.1.0\lib\net45\SQLitePCLRaw.provider.sqlite3.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Configuration.Install" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data.SQLite, Version=1.0.103.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=MSIL">
-      <HintPath>..\packages\System.Data.SQLite.Core.1.0.103\lib\net46\System.Data.SQLite.dll</HintPath>
-      <Private>True</Private>
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\ThirdParty\System.Data.SQLite.ManagedOnly\1.0.94.0\System.Data.SQLite.dll</HintPath>
     </Reference>
     <Reference Include="System.Drawing" />
     <Reference Include="System.IO.Compression" />
@@ -623,6 +631,9 @@
     <Content Include="x64\IM_MOD_RL_yuv_.dll">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="x64\sqlite3.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="x86\CORE_RL_bzlib_.dll">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
@@ -1063,6 +1074,9 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
     <Content Include="Resources\Images\mb3logo800.png" />
+    <Content Include="x86\sqlite3.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\BDInfo\BDInfo.csproj">
@@ -1163,13 +1177,6 @@
     <PostBuildEvent>
     </PostBuildEvent>
   </PropertyGroup>
-  <Import Project="..\packages\System.Data.SQLite.Core.1.0.103\build\net46\System.Data.SQLite.Core.targets" Condition="Exists('..\packages\System.Data.SQLite.Core.1.0.103\build\net46\System.Data.SQLite.Core.targets')" />
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('..\packages\System.Data.SQLite.Core.1.0.103\build\net46\System.Data.SQLite.Core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\System.Data.SQLite.Core.1.0.103\build\net46\System.Data.SQLite.Core.targets'))" />
-  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/MediaBrowser.ServerApplication/packages.config b/MediaBrowser.ServerApplication/packages.config
index e93f13bee..d1958db4d 100644
--- a/MediaBrowser.ServerApplication/packages.config
+++ b/MediaBrowser.ServerApplication/packages.config
@@ -5,5 +5,6 @@
   <package id="ServiceStack.Text" version="4.5.4" targetFramework="net462" />
   <package id="SharpCompress" version="0.14.0" targetFramework="net462" />
   <package id="SimpleInjector" version="3.2.4" targetFramework="net462" />
-  <package id="System.Data.SQLite.Core" version="1.0.103" targetFramework="net462" />
+  <package id="SQLitePCLRaw.core" version="1.1.0" targetFramework="net462" />
+  <package id="SQLitePCLRaw.provider.sqlite3.net45" version="1.1.0" targetFramework="net462" />
 </packages>
\ No newline at end of file
diff --git a/src/Emby.Server/Program.cs b/src/Emby.Server/Program.cs
index 6f871990d..80e56c8ab 100644
--- a/src/Emby.Server/Program.cs
+++ b/src/Emby.Server/Program.cs
@@ -50,6 +50,7 @@ namespace Emby.Server
             //var success = SetDllDirectory(architecturePath);
 
             var appPaths = CreateApplicationPaths(baseDirectory);
+            SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_sqlite3());
 
             var logManager = new NlogManager(appPaths.LogDirectoryPath, "server");
             logManager.ReloadLogger(LogSeverity.Debug);
diff --git a/src/Emby.Server/project.json b/src/Emby.Server/project.json
index 55acee514..170523db1 100644
--- a/src/Emby.Server/project.json
+++ b/src/Emby.Server/project.json
@@ -15,7 +15,8 @@
     "Microsoft.Win32.Registry": "4.0.0",
     "System.Runtime.Extensions": "4.1.0",
     "System.Diagnostics.Process": "4.1.0",
-    "Microsoft.Data.SQLite": "1.1.0-preview1-final"
+    "Microsoft.Data.SQLite": "1.1.0-preview1-final",
+	"SQLitePCLRaw.provider.sqlite3.netstandard11": "1.1.0"
   },
 
   "frameworks": {
-- 
cgit v1.2.3


From 68772e7d9b5273766e3a0e13c60ebec07254a924 Mon Sep 17 00:00:00 2001
From: Luke Pulverenti <luke.pulverenti@gmail.com>
Date: Sat, 3 Dec 2016 02:58:48 -0500
Subject: update details

---
 Emby.Drawing.ImageMagick/ImageMagickEncoder.cs     | 12 +++---
 Emby.Drawing/ImageProcessor.cs                     |  9 ++++-
 .../Library/Validators/PeopleValidator.cs          | 47 +---------------------
 MediaBrowser.Api/Images/ImageRequest.cs            |  2 +
 MediaBrowser.Api/Images/ImageService.cs            |  1 +
 .../Drawing/ImageProcessingOptions.cs              |  2 +
 .../Configuration/PeopleMetadataOptions.cs         | 19 ---------
 .../Configuration/ServerConfiguration.cs           |  4 --
 MediaBrowser.Model/Entities/MediaStream.cs         | 14 ++++++-
 MediaBrowser.Model/MediaBrowser.Model.csproj       |  1 -
 10 files changed, 32 insertions(+), 79 deletions(-)
 delete mode 100644 MediaBrowser.Model/Configuration/PeopleMetadataOptions.cs

(limited to 'Emby.Server.Implementations/Library/Validators')

diff --git a/Emby.Drawing.ImageMagick/ImageMagickEncoder.cs b/Emby.Drawing.ImageMagick/ImageMagickEncoder.cs
index 242898e33..39088c94b 100644
--- a/Emby.Drawing.ImageMagick/ImageMagickEncoder.cs
+++ b/Emby.Drawing.ImageMagick/ImageMagickEncoder.cs
@@ -148,7 +148,7 @@ namespace Emby.Drawing.ImageMagick
             {
                 using (var originalImage = new MagickWand(inputPath))
                 {
-                    ScaleImage(originalImage, width, height);
+                    ScaleImage(originalImage, width, height, options.Blur ?? 0);
 
                     if (autoOrient)
                     {
@@ -170,7 +170,7 @@ namespace Emby.Drawing.ImageMagick
                 {
                     using (var originalImage = new MagickWand(inputPath))
                     {
-                        ScaleImage(originalImage, width, height);
+                        ScaleImage(originalImage, width, height, options.Blur ?? 0);
 
                         if (autoOrient)
                         {
@@ -221,13 +221,13 @@ namespace Emby.Drawing.ImageMagick
             }
         }
 
-        private void ScaleImage(MagickWand wand, int width, int height)
+        private void ScaleImage(MagickWand wand, int width, int height, int blur)
         {
-            var highQuality = false;
+            var useResize = blur > 1;
 
-            if (highQuality)
+            if (useResize)
             {
-                wand.CurrentImage.ResizeImage(width, height);
+                wand.CurrentImage.ResizeImage(width, height, FilterTypes.GaussianFilter, blur);
             }
             else
             {
diff --git a/Emby.Drawing/ImageProcessor.cs b/Emby.Drawing/ImageProcessor.cs
index 2224d544c..a15f75c9a 100644
--- a/Emby.Drawing/ImageProcessor.cs
+++ b/Emby.Drawing/ImageProcessor.cs
@@ -236,7 +236,7 @@ namespace Emby.Drawing
             var quality = options.Quality;
 
             var outputFormat = GetOutputFormat(options.SupportedOutputFormats[0]);
-            var cacheFilePath = GetCacheFilePath(originalImagePath, newSize, quality, dateModified, outputFormat, options.AddPlayedIndicator, options.PercentPlayed, options.UnplayedCount, options.BackgroundColor, options.ForegroundLayer);
+            var cacheFilePath = GetCacheFilePath(originalImagePath, newSize, quality, dateModified, outputFormat, options.AddPlayedIndicator, options.PercentPlayed, options.UnplayedCount, options.Blur, options.BackgroundColor, options.ForegroundLayer);
 
             var imageProcessingLockTaken = false;
 
@@ -469,7 +469,7 @@ namespace Emby.Drawing
         /// <summary>
         /// Gets the cache file path based on a set of parameters
         /// </summary>
-        private string GetCacheFilePath(string originalPath, ImageSize outputSize, int quality, DateTime dateModified, ImageFormat format, bool addPlayedIndicator, double percentPlayed, int? unwatchedCount, string backgroundColor, string foregroundLayer)
+        private string GetCacheFilePath(string originalPath, ImageSize outputSize, int quality, DateTime dateModified, ImageFormat format, bool addPlayedIndicator, double percentPlayed, int? unwatchedCount, int? blur, string backgroundColor, string foregroundLayer)
         {
             var filename = originalPath;
 
@@ -498,6 +498,11 @@ namespace Emby.Drawing
                 filename += "p=" + unwatchedCount.Value;
             }
 
+            if (blur.HasValue)
+            {
+                filename += "blur=" + blur.Value;
+            }
+
             if (!string.IsNullOrEmpty(backgroundColor))
             {
                 filename += "b=" + backgroundColor;
diff --git a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
index 6cd24058a..7ebfd71c0 100644
--- a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
@@ -47,36 +47,6 @@ namespace Emby.Server.Implementations.Library.Validators
             _fileSystem = fileSystem;
         }
 
-        private bool DownloadMetadata(PersonInfo i, PeopleMetadataOptions options)
-        {
-            if (i.IsType(PersonType.Actor))
-            {
-                return options.DownloadActorMetadata;
-            }
-            if (i.IsType(PersonType.Director))
-            {
-                return options.DownloadDirectorMetadata;
-            }
-            if (i.IsType(PersonType.Composer))
-            {
-                return options.DownloadComposerMetadata;
-            }
-            if (i.IsType(PersonType.Writer))
-            {
-                return options.DownloadWriterMetadata;
-            }
-            if (i.IsType(PersonType.Producer))
-            {
-                return options.DownloadProducerMetadata;
-            }
-            if (i.IsType(PersonType.GuestStar))
-            {
-                return options.DownloadGuestStarMetadata;
-            }
-
-            return options.DownloadOtherPeopleMetadata;
-        }
-
         /// <summary>
         /// Validates the people.
         /// </summary>
@@ -89,28 +59,13 @@ namespace Emby.Server.Implementations.Library.Validators
 
             innerProgress.RegisterAction(pct => progress.Report(pct * .15));
 
-            var peopleOptions = _config.Configuration.PeopleMetadataOptions;
-
             var people = _libraryManager.GetPeople(new InternalPeopleQuery());
 
             var dict = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
 
             foreach (var person in people)
             {
-                var isMetadataEnabled = DownloadMetadata(person, peopleOptions);
-
-                bool currentValue;
-                if (dict.TryGetValue(person.Name, out currentValue))
-                {
-                    if (!currentValue && isMetadataEnabled)
-                    {
-                        dict[person.Name] = true;
-                    }
-                }
-                else
-                {
-                    dict[person.Name] = isMetadataEnabled;
-                }
+                dict[person.Name] = true;
             }
 
             var numComplete = 0;
diff --git a/MediaBrowser.Api/Images/ImageRequest.cs b/MediaBrowser.Api/Images/ImageRequest.cs
index ba9ffcc15..b61c81972 100644
--- a/MediaBrowser.Api/Images/ImageRequest.cs
+++ b/MediaBrowser.Api/Images/ImageRequest.cs
@@ -64,6 +64,8 @@ namespace MediaBrowser.Api.Images
         [ApiMember(Name = "UnplayedCount", Description = "Optional unplayed count overlay to render", IsRequired = false, DataType = "int", ParameterType = "query", Verb = "GET")]
         public int? UnplayedCount { get; set; }
 
+        public int? Blur { get; set; }
+
         [ApiMember(Name = "BackgroundColor", Description = "Optional. Apply a background color for transparent images.", IsRequired = false, DataType = "string", ParameterType = "query", Verb = "GET")]
         public string BackgroundColor { get; set; }
 
diff --git a/MediaBrowser.Api/Images/ImageService.cs b/MediaBrowser.Api/Images/ImageService.cs
index f3ad462c4..392654aa2 100644
--- a/MediaBrowser.Api/Images/ImageService.cs
+++ b/MediaBrowser.Api/Images/ImageService.cs
@@ -624,6 +624,7 @@ namespace MediaBrowser.Api.Images
                 AddPlayedIndicator = request.AddPlayedIndicator,
                 PercentPlayed = request.PercentPlayed ?? 0,
                 UnplayedCount = request.UnplayedCount,
+                Blur = request.Blur,
                 BackgroundColor = request.BackgroundColor,
                 ForegroundLayer = request.ForegroundLayer,
                 SupportedOutputFormats = supportedFormats
diff --git a/MediaBrowser.Controller/Drawing/ImageProcessingOptions.cs b/MediaBrowser.Controller/Drawing/ImageProcessingOptions.cs
index 3fd8d84dd..f4b3d9455 100644
--- a/MediaBrowser.Controller/Drawing/ImageProcessingOptions.cs
+++ b/MediaBrowser.Controller/Drawing/ImageProcessingOptions.cs
@@ -35,6 +35,7 @@ namespace MediaBrowser.Controller.Drawing
         public bool AddPlayedIndicator { get; set; }
 
         public int? UnplayedCount { get; set; }
+        public int? Blur { get; set; }
 
         public double PercentPlayed { get; set; }
 
@@ -84,6 +85,7 @@ namespace MediaBrowser.Controller.Drawing
                 !AddPlayedIndicator &&
                 PercentPlayed.Equals(0) &&
                 !UnplayedCount.HasValue &&
+                !Blur.HasValue &&
                 string.IsNullOrEmpty(BackgroundColor) &&
                 string.IsNullOrEmpty(ForegroundLayer);
         }
diff --git a/MediaBrowser.Model/Configuration/PeopleMetadataOptions.cs b/MediaBrowser.Model/Configuration/PeopleMetadataOptions.cs
deleted file mode 100644
index 8564d5b5b..000000000
--- a/MediaBrowser.Model/Configuration/PeopleMetadataOptions.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-namespace MediaBrowser.Model.Configuration
-{
-    public class PeopleMetadataOptions
-    {
-        public bool DownloadActorMetadata { get; set; }
-        public bool DownloadDirectorMetadata { get; set; }
-        public bool DownloadProducerMetadata { get; set; }
-        public bool DownloadWriterMetadata { get; set; }
-        public bool DownloadComposerMetadata { get; set; }
-        public bool DownloadOtherPeopleMetadata { get; set; }
-        public bool DownloadGuestStarMetadata { get; set; }
-
-        public PeopleMetadataOptions()
-        {
-            DownloadActorMetadata = true;
-            DownloadDirectorMetadata = true;
-        }
-    }
-}
\ No newline at end of file
diff --git a/MediaBrowser.Model/Configuration/ServerConfiguration.cs b/MediaBrowser.Model/Configuration/ServerConfiguration.cs
index 64225ae76..520cc9701 100644
--- a/MediaBrowser.Model/Configuration/ServerConfiguration.cs
+++ b/MediaBrowser.Model/Configuration/ServerConfiguration.cs
@@ -181,8 +181,6 @@ namespace MediaBrowser.Model.Configuration
 
         public string UICulture { get; set; }
 
-        public PeopleMetadataOptions PeopleMetadataOptions { get; set; }
-
         public bool SaveMetadataHidden { get; set; }
 
         public NameValuePair[] ContentTypes { get; set; }
@@ -260,8 +258,6 @@ namespace MediaBrowser.Model.Configuration
 
             UICulture = "en-us";
 
-            PeopleMetadataOptions = new PeopleMetadataOptions();
-
             MetadataOptions = new[]
             {
                 new MetadataOptions(1, 1280) {ItemType = "Book"},
diff --git a/MediaBrowser.Model/Entities/MediaStream.cs b/MediaBrowser.Model/Entities/MediaStream.cs
index abdebba4e..85f475ca2 100644
--- a/MediaBrowser.Model/Entities/MediaStream.cs
+++ b/MediaBrowser.Model/Entities/MediaStream.cs
@@ -118,7 +118,9 @@ namespace MediaBrowser.Model.Entities
 
         private string AddLanguageIfNeeded(string title)
         {
-            if (!string.IsNullOrEmpty(Language) && !string.Equals(Language, "und", StringComparison.OrdinalIgnoreCase) && title.IndexOf(Language, StringComparison.OrdinalIgnoreCase) == -1)
+            if (!string.IsNullOrEmpty(Language) && 
+                !string.Equals(Language, "und", StringComparison.OrdinalIgnoreCase) &&
+                !IsLanguageInTitle(title, Language))
             {
                 title = StringHelper.FirstToUpper(Language) + " " + title;
             }
@@ -126,6 +128,16 @@ namespace MediaBrowser.Model.Entities
             return title;
         }
 
+        private bool IsLanguageInTitle(string title, string language)
+        {
+            if (title.IndexOf(Language, StringComparison.OrdinalIgnoreCase) != -1)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
         public string NalLengthSize { get; set; }
 
         /// <summary>
diff --git a/MediaBrowser.Model/MediaBrowser.Model.csproj b/MediaBrowser.Model/MediaBrowser.Model.csproj
index 64472ca3a..f36519e27 100644
--- a/MediaBrowser.Model/MediaBrowser.Model.csproj
+++ b/MediaBrowser.Model/MediaBrowser.Model.csproj
@@ -84,7 +84,6 @@
     <Compile Include="Configuration\FanartOptions.cs" />
     <Compile Include="Configuration\LibraryOptions.cs" />
     <Compile Include="Configuration\MetadataConfiguration.cs" />
-    <Compile Include="Configuration\PeopleMetadataOptions.cs" />
     <Compile Include="Configuration\XbmcMetadataOptions.cs" />
     <Compile Include="Configuration\SubtitlePlaybackMode.cs" />
     <Compile Include="Connect\ConnectAuthenticationExchangeResult.cs" />
-- 
cgit v1.2.3