Feature/netcore preparation (#2072)

* Use platform detection that works on mono 4.6+

* Move to use package reference for restoring nuget packages.

* DateTimeRoutines does not have Nuget packages that support .NET Standard (and therefore .NET Core). We will have to include them for now until we can get rid of this dependency.

* Start spliting some interfaces into their own files - this will help by allowing us to split them out in the future into a seperate project so the actual implementations can stay within their respective architectures when required

* Move out common libraries

* Few more tidy up tasks to get things working with .NET Standard

* Restructure the solution layout

* Encoding work to reduce rework later on platforms without Windows codepages (or require compliance with RFC1345)

* Move folder structure around to have more natural layout of the solutions

* DI server configuration to get rid of "temporary" hack and dependency circle for serverservice

* Make all encoding consistent to match the expected encoding casing for earlier versions of mono.

src/Jackett.Common/Services/CacheService.cs

@@ -0,0 +1,101 @@
+using AutoMapper;
+using Jackett.Indexers;
+using Jackett.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Jackett.Services.Interfaces;
+
+namespace Jackett.Services
+{
+
+    public class CacheService : ICacheService
+    {
+        private readonly List<TrackerCache> cache = new List<TrackerCache>();
+        private readonly int MAX_RESULTS_PER_TRACKER = 1000;
+        private readonly TimeSpan AGE_LIMIT = new TimeSpan(7, 0, 0, 0);
+
+        public void CacheRssResults(IIndexer indexer, IEnumerable<ReleaseInfo> releases)
+        {
+            lock (cache)
+            {
+                var trackerCache = cache.Where(c => c.TrackerId == indexer.ID).FirstOrDefault();
+                if (trackerCache == null)
+                {
+                    trackerCache = new TrackerCache();
+                    trackerCache.TrackerId = indexer.ID;
+                    trackerCache.TrackerName = indexer.DisplayName;
+                    cache.Add(trackerCache);
+                }
+
+                foreach(var release in releases.OrderByDescending(i=>i.PublishDate))
+                {
+                    var existingItem = trackerCache.Results.Where(i => i.Result.Guid == release.Guid).FirstOrDefault();
+                    if (existingItem == null)
+                    {
+                        existingItem = new CachedResult();
+                        existingItem.Created = DateTime.Now;
+                        trackerCache.Results.Add(existingItem);
+                    }
+
+                    existingItem.Result = release;
+                }
+
+                // Prune cache
+                foreach(var tracker in cache)
+                {
+                    tracker.Results = tracker.Results.OrderByDescending(i => i.Created).Take(MAX_RESULTS_PER_TRACKER).ToList();
+                }
+            }
+        }
+
+        public int GetNewItemCount(IIndexer indexer, IEnumerable<ReleaseInfo> releases)
+        {
+            lock (cache)
+            {
+                int newItemCount = 0;
+                var trackerCache = cache.Where(c => c.TrackerId == indexer.ID).FirstOrDefault();
+                if (trackerCache != null)
+                {
+                    foreach (var release in releases)
+                    {
+                        if (trackerCache.Results.Where(i => i.Result.Guid == release.Guid).Count() == 0)
+                        {
+                            newItemCount++;
+                        }
+                    }
+                }
+                else {
+                    newItemCount++;
+                }
+
+                return newItemCount;
+            }
+        }
+
+        public List<TrackerCacheResult> GetCachedResults()
+        {
+            lock (cache)
+            {
+                var results = new List<TrackerCacheResult>();
+
+                foreach(var tracker in cache)
+                {
+                    foreach(var release in tracker.Results.OrderByDescending(i => i.Result.PublishDate).Take(300))
+                    {
+                        var item = Mapper.Map<TrackerCacheResult>(release.Result);
+                        item.FirstSeen = release.Created;
+                        item.Tracker = tracker.TrackerName;
+                        item.TrackerId = tracker.TrackerId;
+                        item.Peers = item.Peers - item.Seeders; // Use peers as leechers
+                        results.Add(item);
+                    }
+                }
+
+                return results.Take(3000).OrderByDescending(i=>i.PublishDate).ToList();
+            }
+        }
+    }
+}