From 0174a3260273d968b5c33c5a94e4f931546ffbcc Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Thu, 5 Jan 2017 11:50:51 -0800
Subject: [PATCH 01/12] Implement Vimeo API client

---
 src/Podsync/Services/PodsyncConfiguration.cs  |   2 +
 src/Podsync/Services/Videos/Vimeo/Group.cs    |  19 +++
 .../Services/Videos/Vimeo/IVimeoClient.cs     |  20 +++
 src/Podsync/Services/Videos/Vimeo/User.cs     |  17 +++
 src/Podsync/Services/Videos/Vimeo/Video.cs    |  21 +++
 .../Services/Videos/Vimeo/VimeoClient.cs      | 140 ++++++++++++++++++
 src/Podsync/Startup.cs                        |   2 +
 src/Podsync/appsettings.json                  |   1 +
 .../Services/Videos/Vimeo/VimeoClientTests.cs |  92 ++++++++++++
 9 files changed, 314 insertions(+)
 create mode 100644 src/Podsync/Services/Videos/Vimeo/Group.cs
 create mode 100644 src/Podsync/Services/Videos/Vimeo/IVimeoClient.cs
 create mode 100644 src/Podsync/Services/Videos/Vimeo/User.cs
 create mode 100644 src/Podsync/Services/Videos/Vimeo/Video.cs
 create mode 100644 src/Podsync/Services/Videos/Vimeo/VimeoClient.cs
 create mode 100644 test/Podsync.Tests/Services/Videos/Vimeo/VimeoClientTests.cs

diff --git a/src/Podsync/Services/PodsyncConfiguration.cs b/src/Podsync/Services/PodsyncConfiguration.cs
index 13e26c1..d31aae7 100644
--- a/src/Podsync/Services/PodsyncConfiguration.cs
+++ b/src/Podsync/Services/PodsyncConfiguration.cs
@@ -6,6 +6,8 @@ namespace Podsync.Services
     {
         public string YouTubeApiKey { get; set; }
 
+        public string VimeoApiKey { get; set; }
+
         public string RedisConnectionString { get; set; }
 
         public string PatreonClientId { get; set; }
diff --git a/src/Podsync/Services/Videos/Vimeo/Group.cs b/src/Podsync/Services/Videos/Vimeo/Group.cs
new file mode 100644
index 0000000..08bbcda
--- /dev/null
+++ b/src/Podsync/Services/Videos/Vimeo/Group.cs
@@ -0,0 +1,19 @@
+using System;
+
+namespace Podsync.Services.Videos.Vimeo
+{
+    public class Group
+    {
+        public string Name { get; set; }
+
+        public string Description { get; set; }
+
+        public Uri Link { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+
+        public Uri Thumbnail { get; set; }
+
+        public string Author { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Podsync/Services/Videos/Vimeo/IVimeoClient.cs b/src/Podsync/Services/Videos/Vimeo/IVimeoClient.cs
new file mode 100644
index 0000000..012ef61
--- /dev/null
+++ b/src/Podsync/Services/Videos/Vimeo/IVimeoClient.cs
@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Podsync.Services.Videos.Vimeo
+{
+    public interface IVimeoClient
+    {
+        Task<Group> Group(string id);
+
+        Task<Group> Channel(string id);
+
+        Task<User> User(string id);
+
+        Task<IEnumerable<Video>> GroupVideos(string id, int count);
+
+        Task<IEnumerable<Video>> UserVideos(string id, int count);
+
+        Task<IEnumerable<Video>> ChannelVideos(string id, int count);
+    }
+}
\ No newline at end of file
diff --git a/src/Podsync/Services/Videos/Vimeo/User.cs b/src/Podsync/Services/Videos/Vimeo/User.cs
new file mode 100644
index 0000000..ed51c4f
--- /dev/null
+++ b/src/Podsync/Services/Videos/Vimeo/User.cs
@@ -0,0 +1,17 @@
+using System;
+
+namespace Podsync.Services.Videos.Vimeo
+{
+    public class User
+    {
+        public string Name { get; set; }
+
+        public string Bio { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+
+        public Uri Link { get; set; }
+
+        public Uri Thumbnail { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Podsync/Services/Videos/Vimeo/Video.cs b/src/Podsync/Services/Videos/Vimeo/Video.cs
new file mode 100644
index 0000000..e01ac47
--- /dev/null
+++ b/src/Podsync/Services/Videos/Vimeo/Video.cs
@@ -0,0 +1,21 @@
+using System;
+
+namespace Podsync.Services.Videos.Vimeo
+{
+    public class Video
+    {
+        public string Title { get; set; }
+
+        public string Description { get; set; }
+
+        public Uri Link { get; set; }
+
+        public Uri Thumbnail { get; set; }
+
+        public DateTime CreatedAt { get; set; }
+
+        public long Size { get; set; }
+
+        public TimeSpan Duration { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Podsync/Services/Videos/Vimeo/VimeoClient.cs b/src/Podsync/Services/Videos/Vimeo/VimeoClient.cs
new file mode 100644
index 0000000..6743422
--- /dev/null
+++ b/src/Podsync/Services/Videos/Vimeo/VimeoClient.cs
@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json.Linq;
+
+namespace Podsync.Services.Videos.Vimeo
+{
+    // ReSharper disable once ClassNeverInstantiated.Global
+    public sealed class VimeoClient : IVimeoClient, IDisposable
+    {
+        private const int MaxPageSize = 100;
+
+        private readonly HttpClient _client = new HttpClient();
+
+        public VimeoClient(IOptions<PodsyncConfiguration> configuration)
+        {
+            _client.BaseAddress = new Uri("https://api.vimeo.com/");
+            _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", configuration.Value.VimeoApiKey);
+        }
+
+        public Task<Group> Group(string id)
+        {
+            return QueryGroup($"groups/{id}");
+        }
+
+        public Task<Group> Channel(string id)
+        {
+            return QueryGroup($"channels/{id}");
+        }
+
+        public async Task<User> User(string id)
+        {
+            dynamic json = await QueryApi($"users/{id}");
+
+            return new User
+            {
+                Name = json.name,
+                Bio = json.bio,
+                Link = new Uri(json.link.ToString()),
+                Thumbnail = new Uri(json.pictures.sizes[0].link.ToString()),
+                CreatedAt = DateTime.Parse(json.created_time.ToString()),
+            };
+        }
+
+        public Task<IEnumerable<Video>> GroupVideos(string id, int count)
+        {
+            return QueryVideos($"groups/{id}/videos", count);
+        }
+
+        public Task<IEnumerable<Video>> UserVideos(string id, int count)
+        {
+            return QueryVideos($"users/{id}/videos", count);
+        }
+
+        public Task<IEnumerable<Video>> ChannelVideos(string id, int count)
+        {
+            return QueryVideos($"channels/{id}/videos", count);
+        }
+
+        public void Dispose()
+        {
+            _client.Dispose();
+        }
+
+        private async Task<IEnumerable<Video>> QueryVideos(string path, int count)
+        {
+            if (count <= 0)
+            {
+                throw new ArgumentException("Invalid item count", nameof(count));
+            }
+
+            var collection = new List<Video>(count);
+            var pageIndex = 1;
+
+            while (count > 0)
+            {
+                var pageSize = Math.Min(count, MaxPageSize);
+
+                await GetPage(path, pageIndex, pageSize, collection);
+
+                count -= pageSize;
+                pageIndex++;
+            }
+
+            return collection;
+        }
+
+        private async Task GetPage(string path, int pageIndex, int pageSize, List<Video> output)
+        {
+            dynamic resp = await QueryApi($"{path}?per_page={pageSize}&page={pageIndex}");
+
+            foreach (dynamic v in resp.data)
+            {
+                // Approximated file size
+                var size = Convert.ToInt64(
+                    v.width.ToObject<long>() *
+                    v.height.ToObject<long>() *
+                    v.duration.ToObject<long>() *
+                    0.38848958333);
+
+                var video = new Video
+                {
+                    Title = v.name,
+                    Description = v.description,
+                    Link = new Uri(v.link?.ToString()),
+                    Thumbnail = new Uri(v.pictures?.sizes[0]?.link?.ToString()),
+                    CreatedAt = DateTime.Parse(v.created_time?.ToString()),
+                    Duration = TimeSpan.FromSeconds(v.duration?.ToObject<int>()),
+                    Size = size
+                };
+
+                output.Add(video);
+            }
+        }
+
+        private async Task<Group> QueryGroup(string path)
+        {
+            dynamic json = await QueryApi(path);
+
+            return new Group
+            {
+                Name = json.name,
+                Description = json.description,
+                Link = new Uri(json.link?.ToString()),
+                Thumbnail = new Uri(json.pictures?.sizes[0]?.link?.ToString()),
+                CreatedAt = DateTime.Parse(json.created_time?.ToString()),
+                Author = json.user.name,
+            };
+        }
+
+        private async Task<JObject> QueryApi(string path)
+        {
+            var json = await _client.GetStringAsync(path);
+            return JObject.Parse(json);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Podsync/Startup.cs b/src/Podsync/Startup.cs
index dfa0964..c8dc8dd 100644
--- a/src/Podsync/Startup.cs
+++ b/src/Podsync/Startup.cs
@@ -17,6 +17,7 @@ using Podsync.Services.Links;
 using Podsync.Services.Patreon;
 using Podsync.Services.Resolver;
 using Podsync.Services.Storage;
+using Podsync.Services.Videos.Vimeo;
 using Podsync.Services.Videos.YouTube;
 
 namespace Podsync
@@ -51,6 +52,7 @@ namespace Podsync
             // Register core services
             services.AddSingleton<ILinkService, LinkService>();
             services.AddSingleton<IYouTubeClient, YouTubeClient>();
+            services.AddSingleton<IVimeoClient, VimeoClient>();
             services.AddSingleton<IResolverService, YtdlWrapper>();
             services.AddSingleton<IStorageService, RedisStorage>();
             services.AddSingleton<IRssBuilder, CompositeRssBuilder>();
diff --git a/src/Podsync/appsettings.json b/src/Podsync/appsettings.json
index cc3c49d..6952186 100644
--- a/src/Podsync/appsettings.json
+++ b/src/Podsync/appsettings.json
@@ -9,6 +9,7 @@
   },
   "Podsync": {
     "YouTubeApiKey": "",
+    "VimeoApiKey": "",
     "RedisConnectionString": "localhost",
     "BaseUrl": "",
     "PatreonClientId": "",
diff --git a/test/Podsync.Tests/Services/Videos/Vimeo/VimeoClientTests.cs b/test/Podsync.Tests/Services/Videos/Vimeo/VimeoClientTests.cs
new file mode 100644
index 0000000..ace09e8
--- /dev/null
+++ b/test/Podsync.Tests/Services/Videos/Vimeo/VimeoClientTests.cs
@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Podsync.Services.Videos.Vimeo;
+using Xunit;
+
+// ReSharper disable PossibleMultipleEnumeration
+namespace Podsync.Tests.Services.Videos.Vimeo
+{
+    public class VimeoClientTests : TestBase, IDisposable
+    {
+        private readonly VimeoClient _client;
+
+        public VimeoClientTests()
+        {
+            _client = new VimeoClient(Options);
+        }
+        
+        [Fact]
+        public async Task ChannelTest()
+        {
+            var channel = await _client.Channel("staffpicks");
+
+            Assert.Equal(new Uri("https://vimeo.com/channels/staffpicks"), channel.Link);
+            Assert.Equal("Vimeo Staff Picks", channel.Name);
+            Assert.Equal("Vimeo Curation", channel.Author);
+            Assert.False(string.IsNullOrWhiteSpace(channel.Description));
+        }
+
+        [Fact]
+        public async Task GroupTest()
+        {
+            var group = await _client.Group("motion");
+
+            Assert.Equal(new Uri("https://vimeo.com/groups/motion"), group.Link);
+            Assert.Equal("Motion Graphic Artists", group.Name);
+            Assert.Equal("Danny Garcia", group.Author);
+            Assert.False(string.IsNullOrWhiteSpace(group.Description));
+        }
+
+        [Fact]
+        public async Task UserTest()
+        {
+            var user = await _client.User("motionarray");
+
+            Assert.Equal("Motion Array", user.Name);
+            Assert.False(string.IsNullOrWhiteSpace(user.Bio));
+            Assert.Equal(new Uri("https://vimeo.com/motionarray"), user.Link);
+        }
+
+        [Fact]
+        public async Task GroupVideosTest()
+        {
+            var videos = await _client.GroupVideos("motion", 101);
+            Assert.Equal(101, videos.Count());
+            ValidateCollection(videos);
+        }
+
+        [Fact]
+        public async Task UserVideosTest()
+        {
+            var videos = await _client.UserVideos("motionarray", 7);
+            Assert.Equal(7, videos.Count());
+            ValidateCollection(videos);
+        }
+
+        [Fact]
+        public async Task ChannelVideosTest()
+        {
+            var videos = await _client.ChannelVideos("staffpicks", 44);
+            Assert.Equal(44, videos.Count());
+            ValidateCollection(videos);
+        }
+
+        public void Dispose()
+        {
+            _client.Dispose();
+        }
+
+        private void ValidateCollection(IEnumerable<Video> videos)
+        {
+            foreach (var video in videos)
+            {
+                Assert.False(string.IsNullOrWhiteSpace(video.Title));
+                Assert.True(video.Duration.TotalSeconds > 1);
+                Assert.True(video.Size > 0);
+                Assert.NotNull(video.Link);
+            }
+        }
+    }
+}
\ No newline at end of file

From f7e1e388fa9579b4a227877019bcc4bcc39d65b9 Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Thu, 5 Jan 2017 16:47:06 -0800
Subject: [PATCH 02/12] Implement Vimeo RSS builder

---
 src/Podsync/Controllers/FeedController.cs     |   6 +-
 .../Services/Builder/CompositeRssBuilder.cs   |   8 ++
 .../Services/Builder/RssBuilderBase.cs        |   2 -
 .../Services/Builder/VimeoRssBuilder.cs       | 116 ++++++++++++++++++
 .../Services/Builder/YouTubeRssBuilder.cs     |   2 -
 src/Podsync/Services/Constants.cs             |   7 ++
 src/Podsync/Services/Feed/Channel.cs          |   3 +
 .../Services/Builder/VimeoRssBuilderTests.cs  |  65 ++++++++++
 8 files changed, 201 insertions(+), 8 deletions(-)
 create mode 100644 src/Podsync/Services/Builder/VimeoRssBuilder.cs
 create mode 100644 src/Podsync/Services/Constants.cs
 create mode 100644 test/Podsync.Tests/Services/Builder/VimeoRssBuilderTests.cs

diff --git a/src/Podsync/Controllers/FeedController.cs b/src/Podsync/Controllers/FeedController.cs
index e00e6ac..d477e51 100644
--- a/src/Podsync/Controllers/FeedController.cs
+++ b/src/Podsync/Controllers/FeedController.cs
@@ -22,8 +22,6 @@ namespace Podsync.Controllers
     [HandleException]
     public class FeedController : Controller
     {
-        private const int DefaultPageSize = 50;
-
         private readonly XmlSerializer _serializer = new XmlSerializer(typeof(Rss));
 
         private readonly IRssBuilder _rssBuilder;
@@ -52,7 +50,7 @@ namespace Podsync.Controllers
                 LinkType = linkInfo.LinkType,
                 Id = linkInfo.Id,
                 Quality = request.Quality ?? ResolveType.VideoHigh,
-                PageSize = request.PageSize ?? DefaultPageSize
+                PageSize = request.PageSize ?? Constants.DefaultPageSize
             };
 
             // Check if user eligible for Patreon features
@@ -60,7 +58,7 @@ namespace Podsync.Controllers
             if (!enablePatreonFeatures)
             {
                 feed.Quality = ResolveType.VideoHigh;
-                feed.PageSize = DefaultPageSize;
+                feed.PageSize = Constants.DefaultPageSize;
             }
 
             var feedId = await _storageService.Save(feed);
diff --git a/src/Podsync/Services/Builder/CompositeRssBuilder.cs b/src/Podsync/Services/Builder/CompositeRssBuilder.cs
index 77856a2..592d5d9 100644
--- a/src/Podsync/Services/Builder/CompositeRssBuilder.cs
+++ b/src/Podsync/Services/Builder/CompositeRssBuilder.cs
@@ -7,13 +7,16 @@ using Shared;
 
 namespace Podsync.Services.Builder
 {
+    // ReSharper disable once ClassNeverInstantiated.Global
     public class CompositeRssBuilder : RssBuilderBase
     {
         private readonly YouTubeRssBuilder _youTubeBuilder;
+        private readonly VimeoRssBuilder _vimeoBuilder;
 
         public CompositeRssBuilder(IServiceProvider serviceProvider, IStorageService storageService) : base(storageService)
         {
             _youTubeBuilder = serviceProvider.CreateInstance<YouTubeRssBuilder>();
+            _vimeoBuilder = serviceProvider.CreateInstance<VimeoRssBuilder>();
         }
 
         public override Provider Provider
@@ -28,6 +31,11 @@ namespace Podsync.Services.Builder
                 return _youTubeBuilder.Query(baseUrl, feedId, feed);
             }
 
+            if (feed.Provider == Provider.Vimeo)
+            {
+                return _vimeoBuilder.Query(baseUrl, feedId, feed);
+            }
+
             throw new NotSupportedException("Not supported provider");
         }
     }
diff --git a/src/Podsync/Services/Builder/RssBuilderBase.cs b/src/Podsync/Services/Builder/RssBuilderBase.cs
index a3279d3..ec484dc 100644
--- a/src/Podsync/Services/Builder/RssBuilderBase.cs
+++ b/src/Podsync/Services/Builder/RssBuilderBase.cs
@@ -8,8 +8,6 @@ namespace Podsync.Services.Builder
 {
     public abstract class RssBuilderBase : IRssBuilder
     {
-        protected static readonly string DefaultItunesCategory = "TV & Film";
-
         private readonly IStorageService _storageService;
 
         protected RssBuilderBase(IStorageService storageService)
diff --git a/src/Podsync/Services/Builder/VimeoRssBuilder.cs b/src/Podsync/Services/Builder/VimeoRssBuilder.cs
new file mode 100644
index 0000000..e7f45c8
--- /dev/null
+++ b/src/Podsync/Services/Builder/VimeoRssBuilder.cs
@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Podsync.Services.Feed;
+using Podsync.Services.Links;
+using Podsync.Services.Storage;
+using Podsync.Services.Videos.Vimeo;
+
+namespace Podsync.Services.Builder
+{
+    // ReSharper disable once ClassNeverInstantiated.Global
+    public class VimeoRssBuilder : RssBuilderBase
+    {
+        private readonly IVimeoClient _client;
+
+        public VimeoRssBuilder(IStorageService storageService, IVimeoClient client) : base(storageService)
+        {
+            _client = client;
+        }
+
+        public override Provider Provider { get; } = Provider.Vimeo;
+
+        public override async Task<Rss> Query(Uri baseUrl, string feedId, FeedMetadata metadata)
+        {
+            var linkType = metadata.LinkType;
+
+            var id = metadata.Id;
+
+            var pageSize = metadata.PageSize;
+            if (pageSize == 0)
+            {
+                pageSize = Constants.DefaultPageSize;
+            }
+
+            Channel channel = null;
+            if (linkType == LinkType.Channel)
+            {
+                channel = CreateChannel(await _client.Channel(id));
+                channel.Items = CreateItems(await _client.ChannelVideos(id, pageSize));
+            }
+            else if (linkType == LinkType.Group)
+            {
+                channel = CreateChannel(await _client.Group(id));
+                channel.Items = CreateItems(await _client.GroupVideos(id, pageSize));
+            }
+            else if (linkType == LinkType.User)
+            {
+                channel = CreateChannel(await _client.User(id));
+                channel.Items = CreateItems(await _client.UserVideos(id, pageSize));
+            }
+            else
+            {
+                throw new NotSupportedException("URL type is not supported");
+            }
+
+            var rss = new Rss
+            {
+                Channels = new[] { channel }
+            };
+
+            return rss;
+        }
+
+        private static Channel CreateChannel(Group group)
+        {
+            return new Channel
+            {
+                Title = group.Name,
+                Description = group.Description,
+                Link = group.Link,
+                PubDate = group.CreatedAt,
+                Image = group.Thumbnail,
+                Thumbnail = group.Thumbnail,
+                Guid = group.Link.ToString()
+            };
+        }
+
+        private static Channel CreateChannel(User user)
+        {
+            return new Channel
+            {
+                Title = user.Name,
+                Description = user.Bio,
+                Link = user.Link,
+                PubDate = user.CreatedAt,
+                Image = user.Thumbnail,
+                Thumbnail = user.Thumbnail,
+                Guid = user.Link.ToString()
+            };
+        }
+
+        private static Item CreateItem(Video video)
+        {
+            return new Item
+            {
+                Title = video.Title,
+                Description = video.Description,
+                PubDate = video.CreatedAt,
+                Link = video.Link,
+                Duration = video.Duration,
+                Content = new MediaContent
+                {
+                    Length = video.Size,
+                    MediaType = "video/mp4",
+                    Url = null
+                }
+            };
+        }
+
+        private static IEnumerable<Item> CreateItems(IEnumerable<Video> videos)
+        {
+            return videos.Select(CreateItem);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Podsync/Services/Builder/YouTubeRssBuilder.cs b/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
index a9fea37..27e85cc 100644
--- a/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
+++ b/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
@@ -96,11 +96,9 @@ namespace Podsync.Services.Builder
                 Title = item.Title,
                 Description = item.Description,
                 Link = item.Link,
-                LastBuildDate = DateTime.Now,
                 PubDate = item.PublishedAt,
                 Image = item.Thumbnail,
                 Thumbnail = item.Thumbnail,
-                Category = DefaultItunesCategory
             };
         }
 
diff --git a/src/Podsync/Services/Constants.cs b/src/Podsync/Services/Constants.cs
new file mode 100644
index 0000000..1564536
--- /dev/null
+++ b/src/Podsync/Services/Constants.cs
@@ -0,0 +1,7 @@
+namespace Podsync.Services
+{
+    public static class Constants
+    {
+        public const int DefaultPageSize = 50;
+    }
+}
\ No newline at end of file
diff --git a/src/Podsync/Services/Feed/Channel.cs b/src/Podsync/Services/Feed/Channel.cs
index 021590b..eea1ac4 100644
--- a/src/Podsync/Services/Feed/Channel.cs
+++ b/src/Podsync/Services/Feed/Channel.cs
@@ -12,10 +12,13 @@ namespace Podsync.Services.Feed
     public class Channel : IXmlSerializable
     {
         private const string PodsyncGeneratorName = "Podsync Generator";
+        private static readonly string DefaultItunesCategory = "TV & Film";
 
         public Channel()
         {
             Items = Enumerable.Empty<Item>();
+            Category = DefaultItunesCategory;
+            LastBuildDate = DateTime.Now;
         }
 
         public string Guid { get; set; }
diff --git a/test/Podsync.Tests/Services/Builder/VimeoRssBuilderTests.cs b/test/Podsync.Tests/Services/Builder/VimeoRssBuilderTests.cs
new file mode 100644
index 0000000..3ec884e
--- /dev/null
+++ b/test/Podsync.Tests/Services/Builder/VimeoRssBuilderTests.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Moq;
+using Podsync.Services.Builder;
+using Podsync.Services.Links;
+using Podsync.Services.Storage;
+using Podsync.Services.Videos.Vimeo;
+using Xunit;
+
+namespace Podsync.Tests.Services.Builder
+{
+    public class VimeoRssBuilderTests : TestBase
+    {
+        private readonly Mock<IStorageService> _storageService = new Mock<IStorageService>();
+
+        private readonly VimeoRssBuilder _builder;
+
+        public VimeoRssBuilderTests()
+        {
+            _builder = new VimeoRssBuilder(_storageService.Object, new VimeoClient(Options));
+        }
+
+        [Theory]
+        [InlineData(LinkType.Channel, "staffpicks")]
+        [InlineData(LinkType.Group, "motion")]
+        [InlineData(LinkType.User, "motionarray")]
+        public async Task BuildRssTest(LinkType linkType, string id)
+        {
+            var feed = new FeedMetadata
+            {
+                Provider = Provider.YouTube,
+                LinkType = linkType,
+                Id = id
+            };
+
+            var feedId = DateTime.UtcNow.Ticks.ToString();
+
+            _storageService.Setup(x => x.Load(feedId)).ReturnsAsync(feed);
+
+            var rss = await _builder.Query(new Uri("http://localhost:2020"), feedId);
+
+            Assert.NotEmpty(rss.Channels);
+
+            var channel = rss.Channels.Single();
+
+            Assert.NotNull(channel.Title);
+            Assert.NotNull(channel.Description);
+            Assert.NotNull(channel.Image);
+            Assert.NotNull(channel.Guid);
+            Assert.NotEmpty(channel.Items);
+
+            foreach (var item in channel.Items)
+            {
+                Assert.NotNull(item.Title);
+                Assert.NotNull(item.Link);
+                Assert.True(item.Duration.TotalSeconds > 0);
+                Assert.NotNull(item.Content);
+                Assert.True(item.Content.Length > 0);
+                Assert.NotNull(item.Content.MediaType);
+                Assert.NotNull(item.PubDate);
+            }
+        }
+    }
+}
\ No newline at end of file

From c9124cd25e78527e2fa34714c5a4d3d54f39dbc0 Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Thu, 5 Jan 2017 17:25:17 -0800
Subject: [PATCH 03/12] Detect RSS builders automatically via reflection

---
 .../Services/Builder/CompositeRssBuilder.cs   | 24 +++++----
 src/Podsync/Services/Builder/IRssBuilder.cs   |  6 +++
 src/Shared/ServiceProviderExtensions.cs       | 50 +++++++++++++++++++
 3 files changed, 69 insertions(+), 11 deletions(-)

diff --git a/src/Podsync/Services/Builder/CompositeRssBuilder.cs b/src/Podsync/Services/Builder/CompositeRssBuilder.cs
index 592d5d9..fea6c53 100644
--- a/src/Podsync/Services/Builder/CompositeRssBuilder.cs
+++ b/src/Podsync/Services/Builder/CompositeRssBuilder.cs
@@ -1,4 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Reflection;
 using System.Threading.Tasks;
 using Podsync.Services.Feed;
 using Podsync.Services.Links;
@@ -10,13 +14,15 @@ namespace Podsync.Services.Builder
     // ReSharper disable once ClassNeverInstantiated.Global
     public class CompositeRssBuilder : RssBuilderBase
     {
-        private readonly YouTubeRssBuilder _youTubeBuilder;
-        private readonly VimeoRssBuilder _vimeoBuilder;
+        private readonly IDictionary<Provider, IRssBuilder> _builders;
 
         public CompositeRssBuilder(IServiceProvider serviceProvider, IStorageService storageService) : base(storageService)
         {
-            _youTubeBuilder = serviceProvider.CreateInstance<YouTubeRssBuilder>();
-            _vimeoBuilder = serviceProvider.CreateInstance<VimeoRssBuilder>();
+            // Find all RSS builders (all implementations of IRssBuilder), create instances and make dictionary for fast search by Provider type
+            var buildTypes = serviceProvider.FindAllImplementationsOf<IRssBuilder>(Assembly.GetEntryAssembly()).Where(x => x != typeof(CompositeRssBuilder));
+            var builders = buildTypes.Select(builderType => (IRssBuilder)serviceProvider.CreateInstance(builderType)).ToDictionary(builder => builder.Provider);
+
+            _builders = new ReadOnlyDictionary<Provider, IRssBuilder>(builders);
         }
 
         public override Provider Provider
@@ -26,14 +32,10 @@ namespace Podsync.Services.Builder
 
         public override Task<Rss> Query(Uri baseUrl, string feedId, FeedMetadata feed)
         {
-            if (feed.Provider == Provider.YouTube)
+            IRssBuilder builder;
+            if (_builders.TryGetValue(feed.Provider, out builder))
             {
-                return _youTubeBuilder.Query(baseUrl, feedId, feed);
-            }
-
-            if (feed.Provider == Provider.Vimeo)
-            {
-                return _vimeoBuilder.Query(baseUrl, feedId, feed);
+                return builder.Query(baseUrl, feedId, feed);
             }
 
             throw new NotSupportedException("Not supported provider");
diff --git a/src/Podsync/Services/Builder/IRssBuilder.cs b/src/Podsync/Services/Builder/IRssBuilder.cs
index deb6004..e6f2586 100644
--- a/src/Podsync/Services/Builder/IRssBuilder.cs
+++ b/src/Podsync/Services/Builder/IRssBuilder.cs
@@ -1,11 +1,17 @@
 using System;
 using System.Threading.Tasks;
 using Podsync.Services.Feed;
+using Podsync.Services.Links;
+using Podsync.Services.Storage;
 
 namespace Podsync.Services.Builder
 {
     public interface IRssBuilder
     {
+        Provider Provider { get; }
+
         Task<Rss> Query(Uri baseUrl, string feedId);
+
+        Task<Rss> Query(Uri baseUrl, string feedId, FeedMetadata metadata);
     }
 }
\ No newline at end of file
diff --git a/src/Shared/ServiceProviderExtensions.cs b/src/Shared/ServiceProviderExtensions.cs
index 5eae046..82a9182 100644
--- a/src/Shared/ServiceProviderExtensions.cs
+++ b/src/Shared/ServiceProviderExtensions.cs
@@ -1,4 +1,7 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Shared
@@ -19,5 +22,52 @@ namespace Shared
         {
             return ActivatorUtilities.CreateInstance(serviceProvider, type);
         }
+
+        public static IEnumerable<Type> FindAllImplementationsOf(this IServiceProvider serviceProvider, Type interfaceType, Assembly assembly)
+        {
+            if (!interfaceType.GetTypeInfo().IsInterface)
+            {
+                throw new ArgumentException("T should be an interface");
+            }
+
+            return GetLoadableTypes(assembly).Where(type => IsAssignableFrom(interfaceType, type));
+        }
+
+        public static IEnumerable<Type> FindAllImplementationsOf<T>(this IServiceProvider serviceProvider, Assembly assembly)
+        {
+            return serviceProvider.FindAllImplementationsOf(typeof(T), assembly);
+        }
+
+        private static bool IsAssignableFrom(Type interfaceType, Type serviceType)
+        {
+            var serviceTypeInfo = serviceType.GetTypeInfo();
+            if (serviceTypeInfo.IsInterface || serviceTypeInfo.IsAbstract)
+            {
+                return false;
+            }
+
+            var interfaceTypeInfo = interfaceType.GetTypeInfo();
+            if (!interfaceTypeInfo.IsGenericType)
+            {
+                return interfaceType.IsAssignableFrom(serviceType);
+            }
+
+            return serviceType
+                .GetInterfaces()
+                .Where(type => type.GetTypeInfo().IsGenericType)
+                .Any(type => type.GetGenericTypeDefinition() == interfaceType);
+        }
+
+        private static IEnumerable<Type> GetLoadableTypes(Assembly assembly)
+        {
+            try
+            {
+                return assembly.GetTypes();
+            }
+            catch (ReflectionTypeLoadException e)
+            {
+                return e.Types.Where(x => x != null);
+            }
+        }
     }
 }
\ No newline at end of file

From 001cdf4e0a564b97ad585c52043ef0623da328a9 Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Fri, 6 Jan 2017 09:44:19 -0800
Subject: [PATCH 04/12] Generate download links inside controller action

---
 src/Podsync/Controllers/FeedController.cs     | 20 ++++++++-
 .../Services/Builder/CompositeRssBuilder.cs   |  4 +-
 src/Podsync/Services/Builder/IRssBuilder.cs   |  4 +-
 .../Services/Builder/RssBuilderBase.cs        |  6 +--
 .../Services/Builder/VimeoRssBuilder.cs       | 12 +++---
 .../Services/Builder/YouTubeRssBuilder.cs     | 42 +++++++------------
 src/Podsync/Services/Feed/Item.cs             | 28 +++++++++----
 src/Podsync/Services/Feed/MediaContent.cs     | 13 ------
 src/Podsync/Services/Videos/Vimeo/Video.cs    |  4 ++
 .../Services/Videos/Vimeo/VimeoClient.cs      |  8 +++-
 .../Services/Builder/VimeoRssBuilderTests.cs  |  8 ++--
 .../Builder/YouTubeRssBuilderTests.cs         | 10 ++---
 .../Services/Feed/FeedSerializationTests.cs   |  9 ++--
 13 files changed, 87 insertions(+), 81 deletions(-)
 delete mode 100644 src/Podsync/Services/Feed/MediaContent.cs

diff --git a/src/Podsync/Controllers/FeedController.cs b/src/Podsync/Controllers/FeedController.cs
index d477e51..6d36fb0 100644
--- a/src/Podsync/Controllers/FeedController.cs
+++ b/src/Podsync/Controllers/FeedController.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using System.Linq;
 using System.Security.Claims;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
@@ -22,6 +23,12 @@ namespace Podsync.Controllers
     [HandleException]
     public class FeedController : Controller
     {
+        private static readonly IDictionary<string, string> Extensions = new Dictionary<string, string>
+        {
+            ["video/mp4"] = "mp4",
+            ["audio/mp4"] = "m4a"
+        };
+
         private readonly XmlSerializer _serializer = new XmlSerializer(typeof(Rss));
 
         private readonly IRssBuilder _rssBuilder;
@@ -94,18 +101,27 @@ namespace Podsync.Controllers
 
             try
             {
-                rss = await _rssBuilder.Query(Request.GetBaseUrl(), feedId);
+                rss = await _rssBuilder.Query(feedId);
             }
             catch (KeyNotFoundException)
             {
                 return NotFound(feedId);
             }
 
+            var selfHost = Request.GetBaseUrl();
+
             // Set atom link to this feed
             // See https://validator.w3.org/feed/docs/warning/MissingAtomSelfLink.html
-            var selfLink = new Uri($"{Request.Scheme}://{Request.Host}{Request.Path}");
+            var selfLink = new Uri(selfHost, Request.Path);
             rss.Channels.ForEach(x => x.AtomLink = selfLink);
 
+            // No magic here, just make download links to DownloadController.Download
+            rss.Channels.SelectMany(x => x.Items).ForEach(item =>
+            {
+                var ext = Extensions[item.ContentType];
+                item.DownloadLink = new Uri(selfHost, $"download/{feedId}/{item.Id}.{ext}");
+            });
+
             // Serialize feed to string
             string body;
             using (var writer = new Utf8StringWriter())
diff --git a/src/Podsync/Services/Builder/CompositeRssBuilder.cs b/src/Podsync/Services/Builder/CompositeRssBuilder.cs
index fea6c53..19add99 100644
--- a/src/Podsync/Services/Builder/CompositeRssBuilder.cs
+++ b/src/Podsync/Services/Builder/CompositeRssBuilder.cs
@@ -30,12 +30,12 @@ namespace Podsync.Services.Builder
             get { throw new NotSupportedException(); }
         }
 
-        public override Task<Rss> Query(Uri baseUrl, string feedId, FeedMetadata feed)
+        public override Task<Rss> Query(FeedMetadata feed)
         {
             IRssBuilder builder;
             if (_builders.TryGetValue(feed.Provider, out builder))
             {
-                return builder.Query(baseUrl, feedId, feed);
+                return builder.Query(feed);
             }
 
             throw new NotSupportedException("Not supported provider");
diff --git a/src/Podsync/Services/Builder/IRssBuilder.cs b/src/Podsync/Services/Builder/IRssBuilder.cs
index e6f2586..7eb147f 100644
--- a/src/Podsync/Services/Builder/IRssBuilder.cs
+++ b/src/Podsync/Services/Builder/IRssBuilder.cs
@@ -10,8 +10,8 @@ namespace Podsync.Services.Builder
     {
         Provider Provider { get; }
 
-        Task<Rss> Query(Uri baseUrl, string feedId);
+        Task<Rss> Query(string feedId);
 
-        Task<Rss> Query(Uri baseUrl, string feedId, FeedMetadata metadata);
+        Task<Rss> Query(FeedMetadata metadata);
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Builder/RssBuilderBase.cs b/src/Podsync/Services/Builder/RssBuilderBase.cs
index ec484dc..f10e24e 100644
--- a/src/Podsync/Services/Builder/RssBuilderBase.cs
+++ b/src/Podsync/Services/Builder/RssBuilderBase.cs
@@ -17,13 +17,13 @@ namespace Podsync.Services.Builder
 
         public abstract Provider Provider { get; }
 
-        public async Task<Rss> Query(Uri baseUrl, string feedId)
+        public async Task<Rss> Query(string feedId)
         {
             var metadata = await _storageService.Load(feedId);
 
-            return await Query(baseUrl, feedId, metadata);
+            return await Query(metadata);
         }
 
-        public abstract Task<Rss> Query(Uri baseUrl, string feedId, FeedMetadata metadata);
+        public abstract Task<Rss> Query(FeedMetadata metadata);
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Builder/VimeoRssBuilder.cs b/src/Podsync/Services/Builder/VimeoRssBuilder.cs
index e7f45c8..b7e6117 100644
--- a/src/Podsync/Services/Builder/VimeoRssBuilder.cs
+++ b/src/Podsync/Services/Builder/VimeoRssBuilder.cs
@@ -21,7 +21,7 @@ namespace Podsync.Services.Builder
 
         public override Provider Provider { get; } = Provider.Vimeo;
 
-        public override async Task<Rss> Query(Uri baseUrl, string feedId, FeedMetadata metadata)
+        public override async Task<Rss> Query(FeedMetadata metadata)
         {
             var linkType = metadata.LinkType;
 
@@ -94,17 +94,15 @@ namespace Podsync.Services.Builder
         {
             return new Item
             {
+                Id = video.Id,
                 Title = video.Title,
                 Description = video.Description,
                 PubDate = video.CreatedAt,
                 Link = video.Link,
                 Duration = video.Duration,
-                Content = new MediaContent
-                {
-                    Length = video.Size,
-                    MediaType = "video/mp4",
-                    Url = null
-                }
+                FileSize = video.Size,
+                ContentType = "video/mp4",
+                Author = video.Author
             };
         }
 
diff --git a/src/Podsync/Services/Builder/YouTubeRssBuilder.cs b/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
index 27e85cc..6fccfa7 100644
--- a/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
+++ b/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
@@ -13,18 +13,16 @@ namespace Podsync.Services.Builder
 {
     public class YouTubeRssBuilder : RssBuilderBase
     {
-        private readonly ILinkService _linkService;
         private readonly IYouTubeClient _youTube;
 
-        public YouTubeRssBuilder(ILinkService linkService, IYouTubeClient youTube, IStorageService storageService) : base(storageService)
+        public YouTubeRssBuilder(IYouTubeClient youTube, IStorageService storageService) : base(storageService)
         {
-            _linkService = linkService;
             _youTube = youTube;
         }
 
         public override Provider Provider { get; } = Provider.YouTube;
 
-        public override async Task<Rss> Query(Uri baseUrl, string feedId, FeedMetadata metadata)
+        public override async Task<Rss> Query(FeedMetadata metadata)
         {
             if (metadata.Provider != Provider.YouTube)
             {
@@ -57,7 +55,7 @@ namespace Podsync.Services.Builder
             // Get video descriptions
             var videos = await _youTube.GetVideos(new VideoQuery { Id = string.Join(",", ids) });
 
-            channel.Items = videos.Select(youtubeVideo => MakeItem(youtubeVideo, baseUrl, feedId, metadata));
+            channel.Items = videos.Select(youtubeVideo => MakeItem(youtubeVideo, metadata));
 
             var rss = new Rss
             {
@@ -102,46 +100,36 @@ namespace Podsync.Services.Builder
             };
         }
 
-        private Item MakeItem(Video video, Uri baseUrl, string feedId, FeedMetadata feed)
+        private Item MakeItem(Video video, FeedMetadata feed)
         {
-            string contentType;
-            string extension;
-            GetMediaInfo(feed.Quality, out contentType, out extension);
-
-            var downloadUri = _linkService.Download(baseUrl, feedId, video.VideoId, extension);
+            string contentType = GetContentType(feed.Quality);
 
             return new Item
             {
+                Id = video.VideoId,
                 Title = video.Title,
                 Description = video.Description,
                 PubDate = video.PublishedAt,
                 Link = video.Link,
                 Duration = video.Duration,
-                Content = new MediaContent
-                {
-                    Length = video.Size,
-                    MediaType = contentType,
-                    Url = downloadUri
-                }
+                FileSize = video.Size,
+                ContentType = contentType
             };
         }
 
-        private static void GetMediaInfo(ResolveType resolveType, out string contentType, out string extension)
+        private static string GetContentType(ResolveType resolveType)
         {
             if (resolveType == ResolveType.VideoHigh || resolveType == ResolveType.VideoLow)
             {
-                contentType = "video/mp4";
-                extension = ".mp4";
+                return "video/mp4";
             }
-            else if (resolveType == ResolveType.AudioHigh || resolveType == ResolveType.AudioLow)
+
+            if (resolveType == ResolveType.AudioHigh || resolveType == ResolveType.AudioLow)
             {
-                contentType = "audio/mp4";
-                extension = ".m4a";
-            }
-            else
-            {
-                throw new ArgumentException("Unsupported resolve type");
+                return "audio/mp4";
             }
+
+            throw new ArgumentException("Unsupported resolve type");
         }
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Feed/Item.cs b/src/Podsync/Services/Feed/Item.cs
index dec6dbc..1cbc801 100644
--- a/src/Podsync/Services/Feed/Item.cs
+++ b/src/Podsync/Services/Feed/Item.cs
@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using System.Xml;
 using System.Xml.Schema;
 using System.Xml.Serialization;
@@ -22,7 +23,13 @@ namespace Podsync.Services.Feed
 
         public TimeSpan Duration { get; set; }
 
-        public MediaContent Content { get; set; }
+        public string Id { get; set; }
+
+        public long FileSize { get; set; }
+
+        public Uri DownloadLink { get; set; }
+
+        public string ContentType { get; set; }
 
         public XmlSchema GetSchema()
         {
@@ -52,17 +59,22 @@ namespace Podsync.Services.Feed
 
             writer.WriteStartElement("guid");
             writer.WriteAttributeString("isPermaLink", "true");
-            writer.WriteString(Link.ToString());
+            writer.WriteString(Link?.ToString() ?? Id);
             writer.WriteEndElement();
 
             /*
                 <enclosure url="http://podsync.net/download/youtube/yp202t46OIE.mp4" length="48300000" type="video/mp4"/>
             */
 
+            if (DownloadLink == null)
+            {
+                throw new InvalidDataException("Can't generate RSS item with no download link");
+            }
+
             writer.WriteStartElement("enclosure");
-            writer.WriteAttributeString("url", Content.Url.ToString());
-            writer.WriteAttributeString("length", Content.Length.ToString());
-            writer.WriteAttributeString("type", Content.MediaType);
+            writer.WriteAttributeString("url", DownloadLink.ToString());
+            writer.WriteAttributeString("length", FileSize.ToString());
+            writer.WriteAttributeString("type", ContentType);
             writer.WriteEndElement();
 
             /*
@@ -70,9 +82,9 @@ namespace Podsync.Services.Feed
             */
 
             writer.WriteStartElement("content", Namespaces.Media);
-            writer.WriteAttributeString("url", Content.Url.ToString());
-            writer.WriteAttributeString("fileSize", Content.Length.ToString());
-            writer.WriteAttributeString("type", Content.MediaType);
+            writer.WriteAttributeString("url", DownloadLink.ToString());
+            writer.WriteAttributeString("fileSize", FileSize.ToString());
+            writer.WriteAttributeString("type", ContentType);
             writer.WriteEndElement();
 
             /*
diff --git a/src/Podsync/Services/Feed/MediaContent.cs b/src/Podsync/Services/Feed/MediaContent.cs
deleted file mode 100644
index 2277eb5..0000000
--- a/src/Podsync/Services/Feed/MediaContent.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using System;
-
-namespace Podsync.Services.Feed
-{
-    public struct MediaContent
-    {
-        public Uri Url { get; set; }
-
-        public long Length { get; set; }
-
-        public string MediaType { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/src/Podsync/Services/Videos/Vimeo/Video.cs b/src/Podsync/Services/Videos/Vimeo/Video.cs
index e01ac47..aac895f 100644
--- a/src/Podsync/Services/Videos/Vimeo/Video.cs
+++ b/src/Podsync/Services/Videos/Vimeo/Video.cs
@@ -4,6 +4,8 @@ namespace Podsync.Services.Videos.Vimeo
 {
     public class Video
     {
+        public string Id { get; set; }
+
         public string Title { get; set; }
 
         public string Description { get; set; }
@@ -17,5 +19,7 @@ namespace Podsync.Services.Videos.Vimeo
         public long Size { get; set; }
 
         public TimeSpan Duration { get; set; }
+
+        public string Author { get; set; }
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Videos/Vimeo/VimeoClient.cs b/src/Podsync/Services/Videos/Vimeo/VimeoClient.cs
index 6743422..d661e6f 100644
--- a/src/Podsync/Services/Videos/Vimeo/VimeoClient.cs
+++ b/src/Podsync/Services/Videos/Vimeo/VimeoClient.cs
@@ -101,15 +101,21 @@ namespace Podsync.Services.Videos.Vimeo
                     v.duration.ToObject<long>() *
                     0.38848958333);
 
+                // Extract id from uri like '/videos/50522981'
+                var uri = v.uri.ToString();
+                var id = uri.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries)[1];
+
                 var video = new Video
                 {
+                    Id = id,
                     Title = v.name,
                     Description = v.description,
                     Link = new Uri(v.link?.ToString()),
                     Thumbnail = new Uri(v.pictures?.sizes[0]?.link?.ToString()),
                     CreatedAt = DateTime.Parse(v.created_time?.ToString()),
                     Duration = TimeSpan.FromSeconds(v.duration?.ToObject<int>()),
-                    Size = size
+                    Size = size,
+                    Author = v.user.name
                 };
 
                 output.Add(video);
diff --git a/test/Podsync.Tests/Services/Builder/VimeoRssBuilderTests.cs b/test/Podsync.Tests/Services/Builder/VimeoRssBuilderTests.cs
index 3ec884e..276fc42 100644
--- a/test/Podsync.Tests/Services/Builder/VimeoRssBuilderTests.cs
+++ b/test/Podsync.Tests/Services/Builder/VimeoRssBuilderTests.cs
@@ -38,7 +38,7 @@ namespace Podsync.Tests.Services.Builder
 
             _storageService.Setup(x => x.Load(feedId)).ReturnsAsync(feed);
 
-            var rss = await _builder.Query(new Uri("http://localhost:2020"), feedId);
+            var rss = await _builder.Query(feedId);
 
             Assert.NotEmpty(rss.Channels);
 
@@ -52,12 +52,12 @@ namespace Podsync.Tests.Services.Builder
 
             foreach (var item in channel.Items)
             {
+                Assert.NotNull(item.Id);
                 Assert.NotNull(item.Title);
                 Assert.NotNull(item.Link);
                 Assert.True(item.Duration.TotalSeconds > 0);
-                Assert.NotNull(item.Content);
-                Assert.True(item.Content.Length > 0);
-                Assert.NotNull(item.Content.MediaType);
+                Assert.True(item.FileSize > 0);
+                Assert.NotNull(item.ContentType);
                 Assert.NotNull(item.PubDate);
             }
         }
diff --git a/test/Podsync.Tests/Services/Builder/YouTubeRssBuilderTests.cs b/test/Podsync.Tests/Services/Builder/YouTubeRssBuilderTests.cs
index 4cebaa7..42dbb98 100644
--- a/test/Podsync.Tests/Services/Builder/YouTubeRssBuilderTests.cs
+++ b/test/Podsync.Tests/Services/Builder/YouTubeRssBuilderTests.cs
@@ -21,7 +21,7 @@ namespace Podsync.Tests.Services.Builder
             var linkService = new LinkService();
             var client = new YouTubeClient(linkService, Options);
 
-            _builder = new YouTubeRssBuilder(linkService, client, _storageService.Object);
+            _builder = new YouTubeRssBuilder(client, _storageService.Object);
         }
 
         [Theory]
@@ -41,7 +41,7 @@ namespace Podsync.Tests.Services.Builder
 
             _storageService.Setup(x => x.Load(feedId)).ReturnsAsync(feed);
 
-            var rss = await _builder.Query(new Uri("http://localhost:2020"), feedId);
+            var rss = await _builder.Query(feedId);
 
             Assert.NotEmpty(rss.Channels);
 
@@ -58,10 +58,8 @@ namespace Podsync.Tests.Services.Builder
                 Assert.NotNull(item.Title);
                 Assert.NotNull(item.Link);
                 Assert.True(item.Duration.TotalSeconds > 0);
-                Assert.NotNull(item.Content);
-                Assert.True(item.Content.Length > 0);
-                Assert.NotNull(item.Content.MediaType);
-                Assert.NotNull(item.Content.Url);
+                Assert.True(item.FileSize > 0);
+                Assert.NotNull(item.ContentType);
                 Assert.NotNull(item.PubDate);
             }
         }
diff --git a/test/Podsync.Tests/Services/Feed/FeedSerializationTests.cs b/test/Podsync.Tests/Services/Feed/FeedSerializationTests.cs
index 1154494..47a0842 100644
--- a/test/Podsync.Tests/Services/Feed/FeedSerializationTests.cs
+++ b/test/Podsync.Tests/Services/Feed/FeedSerializationTests.cs
@@ -20,12 +20,9 @@ namespace Podsync.Tests.Services.Feed
                 Title = "Steve Gillespie - Getting Arrested (Stand up Comedy)",
                 Link = new Uri("https://youtube.com/watch?v=Jj22gfTnpAI"),
                 PubDate = DateTime.Parse("Mon, 07 Nov 2016 20:02:26 GMT"),
-                Content = new MediaContent
-                {
-                    Url = new Uri("http://podsync.net/download/youtube/Jj22gfTnpAI.mp4"),
-                    Length = 52850000,
-                    MediaType = "video/mp4"
-                },
+                DownloadLink = new Uri("http://podsync.net/download/youtube/Jj22gfTnpAI.mp4"),
+                FileSize = 52850000,
+                ContentType = "video/mp4",
                 Duration = new TimeSpan(0, 0, 2, 31)
             };
 

From dce590a047098e3e1a44ff62c94e7b75e07cf8f5 Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Fri, 6 Jan 2017 10:04:34 -0800
Subject: [PATCH 05/12] Minor code cleanup

---
 src/Podsync/Services/Builder/IRssBuilder.cs     |  3 +--
 src/Podsync/Services/Builder/RssBuilderBase.cs  |  3 +--
 src/Podsync/Services/Builder/VimeoRssBuilder.cs |  2 +-
 src/Podsync/Services/Links/ILinkService.cs      |  2 --
 src/Podsync/Services/Links/LinkService.cs       |  5 -----
 src/Podsync/Views/Shared/Error.cshtml           | 14 --------------
 6 files changed, 3 insertions(+), 26 deletions(-)
 delete mode 100644 src/Podsync/Views/Shared/Error.cshtml

diff --git a/src/Podsync/Services/Builder/IRssBuilder.cs b/src/Podsync/Services/Builder/IRssBuilder.cs
index 7eb147f..7d09f4d 100644
--- a/src/Podsync/Services/Builder/IRssBuilder.cs
+++ b/src/Podsync/Services/Builder/IRssBuilder.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Podsync.Services.Feed;
 using Podsync.Services.Links;
 using Podsync.Services.Storage;
diff --git a/src/Podsync/Services/Builder/RssBuilderBase.cs b/src/Podsync/Services/Builder/RssBuilderBase.cs
index f10e24e..ec82e0d 100644
--- a/src/Podsync/Services/Builder/RssBuilderBase.cs
+++ b/src/Podsync/Services/Builder/RssBuilderBase.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Podsync.Services.Feed;
 using Podsync.Services.Links;
 using Podsync.Services.Storage;
diff --git a/src/Podsync/Services/Builder/VimeoRssBuilder.cs b/src/Podsync/Services/Builder/VimeoRssBuilder.cs
index b7e6117..77c57d6 100644
--- a/src/Podsync/Services/Builder/VimeoRssBuilder.cs
+++ b/src/Podsync/Services/Builder/VimeoRssBuilder.cs
@@ -33,7 +33,7 @@ namespace Podsync.Services.Builder
                 pageSize = Constants.DefaultPageSize;
             }
 
-            Channel channel = null;
+            Channel channel;
             if (linkType == LinkType.Channel)
             {
                 channel = CreateChannel(await _client.Channel(id));
diff --git a/src/Podsync/Services/Links/ILinkService.cs b/src/Podsync/Services/Links/ILinkService.cs
index 3ee0ef6..06f9e7a 100644
--- a/src/Podsync/Services/Links/ILinkService.cs
+++ b/src/Podsync/Services/Links/ILinkService.cs
@@ -8,8 +8,6 @@ namespace Podsync.Services.Links
 
         Uri Make(LinkInfo info);
 
-        Uri Download(Uri baseUrl, string feedId, string videoId, string ext);
-
         Uri Feed(Uri baseUrl, string feedId);
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Links/LinkService.cs b/src/Podsync/Services/Links/LinkService.cs
index f001b9a..facdbd3 100644
--- a/src/Podsync/Services/Links/LinkService.cs
+++ b/src/Podsync/Services/Links/LinkService.cs
@@ -194,11 +194,6 @@ namespace Podsync.Services.Links
             }
         }
 
-        public Uri Download(Uri baseUrl, string feedId, string videoId, string ext)
-        {
-            return new Uri(baseUrl, $"download/{feedId}/{videoId}{ext}");
-        }
-
         public Uri Feed(Uri baseUrl, string feedId)
         {
             return new Uri(baseUrl, feedId);
diff --git a/src/Podsync/Views/Shared/Error.cshtml b/src/Podsync/Views/Shared/Error.cshtml
deleted file mode 100644
index e514139..0000000
--- a/src/Podsync/Views/Shared/Error.cshtml
+++ /dev/null
@@ -1,14 +0,0 @@
-@{
-    ViewData["Title"] = "Error";
-}
-
-<h1 class="text-danger">Error.</h1>
-<h2 class="text-danger">An error occurred while processing your request.</h2>
-
-<h3>Development Mode</h3>
-<p>
-    Swapping to <strong>Development</strong> environment will display more detailed information about the error that occurred.
-</p>
-<p>
-    <strong>Development environment should not be enabled in deployed applications</strong>, as it can result in sensitive information from exceptions being displayed to end users. For local debugging, development environment can be enabled by setting the <strong>ASPNETCORE_ENVIRONMENT</strong> environment variable to <strong>Development</strong>, and restarting the application.
-</p>

From 18bbaeec6d3ed1b5595acf0e192a976c7ee394cd Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Fri, 6 Jan 2017 13:36:14 -0800
Subject: [PATCH 06/12] Parse vimeo links

---
 src/Podsync/Services/Links/LinkService.cs     | 39 ++++++++++++++++++-
 .../Services/Links/LinkServiceTests.cs        | 17 ++++++++
 2 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/src/Podsync/Services/Links/LinkService.cs b/src/Podsync/Services/Links/LinkService.cs
index facdbd3..9d9822c 100644
--- a/src/Podsync/Services/Links/LinkService.cs
+++ b/src/Podsync/Services/Links/LinkService.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.RegularExpressions;
 using Microsoft.AspNetCore.WebUtilities;
 using Shared;
 
@@ -28,6 +29,19 @@ namespace Podsync.Services.Links
             }
         };
 
+        /*
+            Test input:
+            https://vimeo.com/groups/109
+            http://vimeo.com/groups/109
+            http://www.vimeo.com/groups/109
+            https://vimeo.com/groups/109/videos/
+            https://vimeo.com/channels/staffpicks
+            https://vimeo.com/channels/staffpicks/146224925
+            https://vimeo.com/awhitelabelproduct
+            vimeo.com/groups/109             
+        */
+        private static readonly Regex VimeoRegex = new Regex(@"^(?:https?://)?(?:www\.)?(?:vimeo.com/)(?<grp>groups|channels)?/?(?<id>\w+)", RegexOptions.Compiled);
+
         public LinkInfo Parse(Uri link)
         {
             if (link == null)
@@ -162,10 +176,33 @@ namespace Podsync.Services.Links
                     }
                 }
             }
+            else
+            {
+                var match = VimeoRegex.Match(link.AbsoluteUri);
+                if (match.Success)
+                {
+                    provider = Provider.Vimeo;
+                    id = match.Groups["id"]?.ToString();
+
+                    var type = match.Groups["grp"]?.ToString();
+                    if (type == "groups")
+                    {
+                        linkType = LinkType.Group;
+                    }
+                    else if (type == "channels")
+                    {
+                        linkType = LinkType.Channel;
+                    }
+                    else
+                    {
+                        linkType = LinkType.User;
+                    }
+                }
+            }
 
             if (string.IsNullOrWhiteSpace(id) || linkType == LinkType.Unknown || provider == Provider.Unknown)
             {
-                throw new ArgumentException("This provider is not supported");
+                throw new ArgumentException("Not supported provider or link format");
             }
             
             return new LinkInfo
diff --git a/test/Podsync.Tests/Services/Links/LinkServiceTests.cs b/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
index e50d408..709dd8a 100644
--- a/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
+++ b/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
@@ -40,6 +40,23 @@ namespace Podsync.Tests.Services.Links
             Assert.Equal(info.Provider, provider);
         }
 
+        [Theory]
+        [InlineData("https://vimeo.com/groups/101", LinkType.Group, "101")]
+        [InlineData("http://vimeo.com/groups/102", LinkType.Group, "102")]
+        [InlineData("http://www.vimeo.com/groups/103", LinkType.Group, "103")]
+        [InlineData("https://vimeo.com/awhitelabelproduct", LinkType.User, "awhitelabelproduct")]
+        [InlineData("https://vimeo.com/groups/104/videos/", LinkType.Group, "104")]
+        [InlineData("https://vimeo.com/channels/staffpicks", LinkType.Channel, "staffpicks")]
+        [InlineData("https://vimeo.com/channels/staffpicks/146224925", LinkType.Channel, "staffpicks")]
+        public void ParseVimeoLinks(string link, LinkType linkType, string id)
+        {
+            var info = _linkService.Parse(new Uri(link));
+
+            Assert.Equal(info.Id, id);
+            Assert.Equal(info.LinkType, linkType);
+            Assert.Equal(info.Provider, Provider.Vimeo);
+        }
+
         [Fact]
         public void ParseInvalidLinkTest()
         {

From 11b0e4b4d41210219c366a00dcfe87034c9b6177 Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Fri, 6 Jan 2017 14:12:55 -0800
Subject: [PATCH 07/12] Simplify YouTube links parser

---
 src/Podsync/Services/Links/LinkService.cs     | 162 +++++-------------
 src/Podsync/Services/Links/LinkType.cs        |   2 -
 .../Services/Links/LinkServiceTests.cs        |  35 +---
 3 files changed, 53 insertions(+), 146 deletions(-)

diff --git a/src/Podsync/Services/Links/LinkService.cs b/src/Podsync/Services/Links/LinkService.cs
index 9d9822c..e05a08d 100644
--- a/src/Podsync/Services/Links/LinkService.cs
+++ b/src/Podsync/Services/Links/LinkService.cs
@@ -1,9 +1,8 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text.RegularExpressions;
 using Microsoft.AspNetCore.WebUtilities;
-using Shared;
+using Microsoft.Extensions.Primitives;
 
 namespace Podsync.Services.Links
 {
@@ -15,21 +14,29 @@ namespace Podsync.Services.Links
             {
                 [LinkType.Video] = "https://youtube.com/watch?v={0}",
                 [LinkType.Channel] = "https://youtube.com/channel/{0}",
-                [LinkType.Playlist] = "https://youtube.com/playlist?list={0}",
-                [LinkType.Info] = "https://youtube.com/get_video_info?video_id={0}"
+                [LinkType.Playlist] = "https://youtube.com/playlist?list={0}"
             },
 
             [Provider.Vimeo] = new Dictionary<LinkType, string>
             {
-                [LinkType.Category] = "https://vimeo.com/categories/{0}",
                 [LinkType.Channel] = "https://vimeo.com/channels/{0}",
                 [LinkType.Group] = "https://vimeo.com/groups/{0}",
-                [LinkType.User] = "https://vimeo.com/{0}",
-                [LinkType.Info] = "https://player.vimeo.com/video/{0}/config"
+                [LinkType.User] = "https://vimeo.com/{0}"
             }
         };
 
         /*
+            YouTube users, channels and playlists
+            Test input:
+            https://www.youtube.com/playlist?list=PLCB9F975ECF01953C
+            https://www.youtube.com/channel/UC5XPnUk8Vvv_pWslhwom6Og
+            https://www.youtube.com/user/fxigr1
+         */
+
+        private static readonly Regex YouTubeRegex = new Regex(@"^(?:https?://)?(?:www\.)?(?:youtube.com/)(?<type>user|channel|playlist|watch)/?(?<id>\w+)?", RegexOptions.Compiled);
+
+        /*
+            Vimeo groups, channels and users
             Test input:
             https://vimeo.com/groups/109
             http://vimeo.com/groups/109
@@ -38,9 +45,8 @@ namespace Podsync.Services.Links
             https://vimeo.com/channels/staffpicks
             https://vimeo.com/channels/staffpicks/146224925
             https://vimeo.com/awhitelabelproduct
-            vimeo.com/groups/109             
         */
-        private static readonly Regex VimeoRegex = new Regex(@"^(?:https?://)?(?:www\.)?(?:vimeo.com/)(?<grp>groups|channels)?/?(?<id>\w+)", RegexOptions.Compiled);
+        private static readonly Regex VimeoRegex = new Regex(@"^(?:https?://)?(?:www\.)?(?:vimeo.com/)(?<type>groups|channels)?/?(?<id>\w+)", RegexOptions.Compiled);
 
         public LinkInfo Parse(Uri link)
         {
@@ -54,147 +60,69 @@ namespace Podsync.Services.Links
 
             var id = string.Empty;
 
-            var segments = link.Segments
-                .Select(x => x.TrimEnd('/'))
-                .Where(x => !string.IsNullOrWhiteSpace(x))
-                .ToArray();
-
-            var host = link.Host.ToLowerInvariant().TrimStart("www.").TrimStart("m.");
-
-            if (host == "youtu.be")
+            // YouTube
+            var match = YouTubeRegex.Match(link.AbsoluteUri);
+            if (match.Success)
             {
                 provider = Provider.YouTube;
 
-                if (segments.Length == 1)
+                var type = match.Groups["type"]?.ToString();
+                if (type == "user")
                 {
-                    // https://youtu.be/AAAAAAAAA01
-                    // https://www.youtu.be/AAAAAAAAA08
+                    // https://www.youtube.com/user/fxigr1
 
-                    linkType = LinkType.Video;
-                    id = segments.Single();
-                }
-            }
-            else if (host == "youtube.com")
-            {
-                provider = Provider.YouTube;
-
-                var query = QueryHelpers.ParseQuery(link.Query);
-
-                if (segments.Length >= 2 && segments[0] == "user")
-                {
+                    id = match.Groups["id"]?.ToString();
                     linkType = LinkType.User;
-                    id = segments[1];
                 }
-                else if (segments.Length == 2)
+                else if (type == "channel")
                 {
-                    if (string.Equals(segments[0], "embed"))
-                    {
-                        linkType = LinkType.Video;
+                    // https://www.youtube.com/channel/UC5XPnUk8Vvv_pWslhwom6Og
 
-                        if (string.Equals(segments[1], "watch"))
-                        {
-                            // http://www.youtube.com/embed/watch?feature=player_embedded&v=AAAAAAAAA02
-                            // http://www.youtube.com/embed/watch?v=AAAAAAAAA03
-
-                            id = query["v"];
-                        }
-                        else if (segments[1].StartsWith("v="))
-                        {
-                            // http://www.youtube.com/embed/v=AAAAAAAAA04
-                            
-                            id = segments[1].TrimStart("v=");
-                        }
-                    }
-                    else if (string.Equals(segments[0], "watch"))
-                    {
-                        // http://www.youtube.com/watch/jMeC7JFQ6811
-
-                        linkType = LinkType.Video;
-                        id = segments[1];
-                    }
-                    else if (string.Equals(segments[0], "v"))
-                    {
-                        // http://www.youtube.com/v/jMeC7JFQ6812
-                        // http://www.youtube.com/v/A-AAAAAAA18?fs=1&rel=0
-
-                        linkType = LinkType.Video;
-                        id = segments[1];
-                    }
-                    else if (string.Equals(segments[0], "channel"))
-                    {
-                        // https://www.youtube.com/channel/UC5XPnUk8Vvv_pWslhwom6Og
-
-                        linkType = LinkType.Channel;
-                        id = segments[1];
-                    }
+                    id = match.Groups["id"]?.ToString();
+                    linkType = LinkType.Channel;
                 }
-
-                else if (segments.Length == 1)
+                else if (type == "playlist" || type == "watch")
                 {
-                    if (string.Equals(segments[0], "watch"))
+                    // https://www.youtube.com/playlist?list=PLCB9F975ECF01953C
+                    // https://www.youtube.com/watch?v=otm9NaT9OWU&list=PLCB9F975ECF01953C
+
+                    var qs = QueryHelpers.ParseQuery(link.Query);
+
+                    StringValues list;
+                    if (qs.TryGetValue("list", out list))
                     {
-                        if (query.ContainsKey("list"))
-                        {
-                            // https://www.youtube.com/watch?v=otm9NaT9OWU&list=PLCB9F975ECF01953C
-
-                            linkType = LinkType.Playlist;
-                            id = query["list"];
-                        }
-                        else
-                        {
-                            // http://www.youtube.com/watch?v=AAAAAAAAA06
-                            // http://www.youtube.com/watch?feature=player_embedded&v=AAAAAAAAA05
-
-                            linkType = LinkType.Video;
-                            id = query["v"];
-                        }
+                        id = list;
                     }
-                    else if (string.Equals(segments[0], "attribution_link"))
-                    {
-                        // http://www.youtube.com/attribution_link?u=/watch?v=jMeC7JFQ6815&feature=share&a=9QlmP1yvjcllp0h3l0NwuA
-                        // http://www.youtube.com/attribution_link?a=fF1CWYwxCQ4&u=/watch?v=jMeC7JFQ6816&feature=em-uploademail 
-                        // http://www.youtube.com/attribution_link?a=fF1CWYwxCQ4&feature=em-uploademail&u=/watch?v=jMeC7JFQ6817 
 
-                        string u = query["u"];
-
-                        var pos = u?.IndexOf("?", StringComparison.OrdinalIgnoreCase) ?? -1;
-                        if (pos != -1)
-                        {
-                            // ReSharper disable once PossibleNullReferenceException
-                            var attrQueryParams = QueryHelpers.ParseQuery(u.Substring(pos));
-
-                            linkType = LinkType.Video;
-                            id = attrQueryParams["v"];
-                        }
-                    }
-                    else if (string.Equals(segments[0], "playlist"))
-                    {
-                        // https://www.youtube.com/playlist?list=PLCB9F975ECF01953C
-
-                        linkType = LinkType.Playlist;
-                        id = query["list"];
-                    }
+                    linkType = LinkType.Playlist;
                 }
             }
             else
             {
-                var match = VimeoRegex.Match(link.AbsoluteUri);
+                // Vimeo
+                match = VimeoRegex.Match(link.AbsoluteUri);
                 if (match.Success)
                 {
                     provider = Provider.Vimeo;
                     id = match.Groups["id"]?.ToString();
 
-                    var type = match.Groups["grp"]?.ToString();
+                    var type = match.Groups["type"]?.ToString();
                     if (type == "groups")
                     {
+                        // https://vimeo.com/groups/109
+
                         linkType = LinkType.Group;
                     }
                     else if (type == "channels")
                     {
+                        // https://vimeo.com/channels/staffpicks
+
                         linkType = LinkType.Channel;
                     }
                     else
                     {
+                        // https://vimeo.com/awhitelabelproduct
+
                         linkType = LinkType.User;
                     }
                 }
diff --git a/src/Podsync/Services/Links/LinkType.cs b/src/Podsync/Services/Links/LinkType.cs
index 4d0dd94..c6e14a4 100644
--- a/src/Podsync/Services/Links/LinkType.cs
+++ b/src/Podsync/Services/Links/LinkType.cs
@@ -7,8 +7,6 @@
         Playlist,
         User,
         Channel,
-        Info,
-        Category,
         Group
     }
 }
\ No newline at end of file
diff --git a/test/Podsync.Tests/Services/Links/LinkServiceTests.cs b/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
index 709dd8a..04af068 100644
--- a/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
+++ b/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
@@ -9,35 +9,19 @@ namespace Podsync.Tests.Services.Links
         private readonly ILinkService _linkService = new LinkService();
 
         [Theory]
-        [InlineData("http://youtu.be/jMeC7JFQ6801", Provider.YouTube, LinkType.Video, "jMeC7JFQ6801")]
-        [InlineData("http://www.youtube.com/embed/watch?feature=player_embedded&v=jMeC7JFQ6802", Provider.YouTube, LinkType.Video, "jMeC7JFQ6802")]
-        [InlineData("http://www.youtube.com/embed/watch?v=jMeC7JFQ6803", Provider.YouTube, LinkType.Video, "jMeC7JFQ6803")]
-        [InlineData("http://www.youtube.com/embed/v=jMeC7JFQ6804", Provider.YouTube, LinkType.Video, "jMeC7JFQ6804")]
-        [InlineData("http://www.youtube.com/watch?v=jMeC7JFQ6806", Provider.YouTube, LinkType.Video, "jMeC7JFQ6806")]
-        [InlineData("http://www.youtube.com/watch?v=jMeC7JFQ6807", Provider.YouTube, LinkType.Video, "jMeC7JFQ6807")]
-        [InlineData("http://www.youtu.be/jMeC7JFQ6808", Provider.YouTube, LinkType.Video, "jMeC7JFQ6808")]
-        [InlineData("http://youtu.be/jMeC7JFQ6809", Provider.YouTube, LinkType.Video, "jMeC7JFQ6809")]
-        [InlineData("http://www.youtube.com/watch?feature=player_embedded&v=jMeC7JFQ6805", Provider.YouTube, LinkType.Video, "jMeC7JFQ6805")]
-        [InlineData("http://www.youtube.com/attribution_link?u=/watch?v=jMeC7JFQ6815&feature=share&a=9QlmP1yvjcllp0h3l0NwuA", Provider.YouTube, LinkType.Video, "jMeC7JFQ6815")]
-        [InlineData("http://www.youtube.com/attribution_link?a=fF1CWYwxCQ4&u=/watch?v=jMeC7JFQ6816&feature=em-uploademail", Provider.YouTube, LinkType.Video, "jMeC7JFQ6816")]
-        [InlineData("http://www.youtube.com/attribution_link?a=fF1CWYwxCQ4&feature=em-uploademail&u=/watch?v=jMeC7JFQ6817", Provider.YouTube, LinkType.Video, "jMeC7JFQ6817")]
-        [InlineData("http://youtube.com/watch?v=jMeC7JFQ6810", Provider.YouTube, LinkType.Video, "jMeC7JFQ6810")]
-        [InlineData("http://www.youtube.com/watch/jMeC7JFQ6811", Provider.YouTube, LinkType.Video, "jMeC7JFQ6811")]
-        [InlineData("http://www.youtube.com/v/jMeC7JFQ6812", Provider.YouTube, LinkType.Video, "jMeC7JFQ6812")]
-        [InlineData("http://WWW.YOUTUBE.COM/v/jMeC7JFQ6812", Provider.YouTube, LinkType.Video, "jMeC7JFQ6812")]
-        [InlineData("https://www.youtube.com/playlist?list=PLCB9F975ECF01953C", Provider.YouTube, LinkType.Playlist, "PLCB9F975ECF01953C")]
-        [InlineData("https://www.youtube.com/watch?v=otm9NaT9OWU&list=PLCB9F975ECF01953C", Provider.YouTube, LinkType.Playlist, "PLCB9F975ECF01953C")]
-        [InlineData("https://www.youtube.com/channel/UC5XPnUk8Vvv_pWslhwom6Og", Provider.YouTube, LinkType.Channel, "UC5XPnUk8Vvv_pWslhwom6Og")]
-        [InlineData("https://www.youtube.com/user/UC5XPnUk8Vvv_pWslhwom6Og", Provider.YouTube, LinkType.User, "UC5XPnUk8Vvv_pWslhwom6Og")]
-        [InlineData("https://www.youtube.com/user/ComboBreakerVideo/videos", Provider.YouTube, LinkType.User, "ComboBreakerVideo")]
-        [InlineData("https://www.youtube.com/user/UC5XPnUk8Vvv_pWslhwom6Og/playlists", Provider.YouTube, LinkType.User, "UC5XPnUk8Vvv_pWslhwom6Og")]
-        public void ParseLinkTest(string link, Provider provider, LinkType linkType, string id)
+        [InlineData("https://www.youtube.com/playlist?list=PLCB9F975ECF01953C", LinkType.Playlist, "PLCB9F975ECF01953C")]
+        [InlineData("https://www.youtube.com/watch?v=otm9NaT9OWU&list=PLCB9F975ECF01953C", LinkType.Playlist, "PLCB9F975ECF01953C")]
+        [InlineData("https://www.youtube.com/channel/UC5XPnUk8Vvv_pWslhwom6Og", LinkType.Channel, "UC5XPnUk8Vvv_pWslhwom6Og")]
+        [InlineData("https://www.youtube.com/user/UC5XPnUk8Vvv_pWslhwom6Og", LinkType.User, "UC5XPnUk8Vvv_pWslhwom6Og")]
+        [InlineData("https://www.youtube.com/user/ComboBreakerVideo/videos", LinkType.User, "ComboBreakerVideo")]
+        [InlineData("https://www.youtube.com/user/UC5XPnUk8Vvv_pWslhwom6Og/playlists", LinkType.User, "UC5XPnUk8Vvv_pWslhwom6Og")]
+        public void ParseYoutubeLinks(string link, LinkType linkType, string id)
         {
             var info = _linkService.Parse(new Uri(link));
 
             Assert.Equal(info.Id, id);
             Assert.Equal(info.LinkType, linkType);
-            Assert.Equal(info.Provider, provider);
+            Assert.Equal(info.Provider, Provider.YouTube);
         }
 
         [Theory]
@@ -68,12 +52,9 @@ namespace Podsync.Tests.Services.Links
         [InlineData(Provider.YouTube, LinkType.Channel, "123", "https://youtube.com/channel/123")]
         [InlineData(Provider.YouTube, LinkType.Playlist, "213", "https://youtube.com/playlist?list=213")]
         [InlineData(Provider.YouTube, LinkType.Video, "321", "https://youtube.com/watch?v=321")]
-        [InlineData(Provider.YouTube, LinkType.Info, "111", "https://youtube.com/get_video_info?video_id=111")]
-        [InlineData(Provider.Vimeo, LinkType.Category, "xyz", "https://vimeo.com/categories/xyz")]
         [InlineData(Provider.Vimeo, LinkType.Channel, "yzx", "https://vimeo.com/channels/yzx")]
         [InlineData(Provider.Vimeo, LinkType.Group, "zyd", "https://vimeo.com/groups/zyd")]
         [InlineData(Provider.Vimeo, LinkType.User, "dfz", "https://vimeo.com/dfz")]
-        [InlineData(Provider.Vimeo, LinkType.Info, "xgd", "https://player.vimeo.com/video/xgd/config")]
         public void MakeLinkTest(Provider provider, LinkType linkType, string id, string expected)
         {
             var info = new LinkInfo

From 9164833f4b73eff872782230cf896eccf376f490 Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Fri, 6 Jan 2017 16:10:28 -0800
Subject: [PATCH 08/12] Fix issues with download links

---
 src/Podsync/Services/Builder/VimeoRssBuilder.cs   | 4 ++--
 src/Podsync/Services/Builder/YouTubeRssBuilder.cs | 2 +-
 src/Podsync/Services/Feed/Channel.cs              | 7 ++-----
 src/Podsync/Services/Links/LinkService.cs         | 3 ++-
 4 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/Podsync/Services/Builder/VimeoRssBuilder.cs b/src/Podsync/Services/Builder/VimeoRssBuilder.cs
index 77c57d6..d9ea5cc 100644
--- a/src/Podsync/Services/Builder/VimeoRssBuilder.cs
+++ b/src/Podsync/Services/Builder/VimeoRssBuilder.cs
@@ -106,9 +106,9 @@ namespace Podsync.Services.Builder
             };
         }
 
-        private static IEnumerable<Item> CreateItems(IEnumerable<Video> videos)
+        private static Item[] CreateItems(IEnumerable<Video> videos)
         {
-            return videos.Select(CreateItem);
+            return videos.Select(CreateItem).ToArray();
         }
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Builder/YouTubeRssBuilder.cs b/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
index 6fccfa7..694031a 100644
--- a/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
+++ b/src/Podsync/Services/Builder/YouTubeRssBuilder.cs
@@ -55,7 +55,7 @@ namespace Podsync.Services.Builder
             // Get video descriptions
             var videos = await _youTube.GetVideos(new VideoQuery { Id = string.Join(",", ids) });
 
-            channel.Items = videos.Select(youtubeVideo => MakeItem(youtubeVideo, metadata));
+            channel.Items = videos.Select(youtubeVideo => MakeItem(youtubeVideo, metadata)).ToArray();
 
             var rss = new Rss
             {
diff --git a/src/Podsync/Services/Feed/Channel.cs b/src/Podsync/Services/Feed/Channel.cs
index eea1ac4..6e3f483 100644
--- a/src/Podsync/Services/Feed/Channel.cs
+++ b/src/Podsync/Services/Feed/Channel.cs
@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml;
 using System.Xml.Schema;
 using System.Xml.Serialization;
@@ -12,11 +10,10 @@ namespace Podsync.Services.Feed
     public class Channel : IXmlSerializable
     {
         private const string PodsyncGeneratorName = "Podsync Generator";
-        private static readonly string DefaultItunesCategory = "TV & Film";
+        private const string DefaultItunesCategory = "TV & Film";
 
         public Channel()
         {
-            Items = Enumerable.Empty<Item>();
             Category = DefaultItunesCategory;
             LastBuildDate = DateTime.Now;
         }
@@ -43,7 +40,7 @@ namespace Podsync.Services.Feed
 
         public Uri Thumbnail { get; set; }
 
-        public IEnumerable<Item> Items { get; set; }
+        public Item[] Items { get; set; }
 
         public bool Explicit { get; set; }
 
diff --git a/src/Podsync/Services/Links/LinkService.cs b/src/Podsync/Services/Links/LinkService.cs
index e05a08d..dc92bba 100644
--- a/src/Podsync/Services/Links/LinkService.cs
+++ b/src/Podsync/Services/Links/LinkService.cs
@@ -21,7 +21,8 @@ namespace Podsync.Services.Links
             {
                 [LinkType.Channel] = "https://vimeo.com/channels/{0}",
                 [LinkType.Group] = "https://vimeo.com/groups/{0}",
-                [LinkType.User] = "https://vimeo.com/{0}"
+                [LinkType.User] = "https://vimeo.com/user{0}",
+                [LinkType.Video] = "https://vimeo.com/{0}"
             }
         };
 

From ab206fb09d0c83060b5f37c3a2da1f88bf8cb92e Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Fri, 6 Jan 2017 17:47:42 -0800
Subject: [PATCH 09/12] Rework Redis serialization

---
 src/Podsync/Services/Constants.cs             |   6 +-
 src/Podsync/Services/Storage/FeedMetadata.cs  |  11 +-
 src/Podsync/Services/Storage/RedisStorage.cs  | 110 +++++++++++-------
 .../Services/Storage/RedisStorageTests.cs     |  19 ++-
 4 files changed, 91 insertions(+), 55 deletions(-)

diff --git a/src/Podsync/Services/Constants.cs b/src/Podsync/Services/Constants.cs
index 1564536..e5ab7cd 100644
--- a/src/Podsync/Services/Constants.cs
+++ b/src/Podsync/Services/Constants.cs
@@ -1,7 +1,11 @@
-namespace Podsync.Services
+using Podsync.Services.Resolver;
+
+namespace Podsync.Services
 {
     public static class Constants
     {
         public const int DefaultPageSize = 50;
+
+        public const ResolveType DefaultFormat = ResolveType.VideoHigh;
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Storage/FeedMetadata.cs b/src/Podsync/Services/Storage/FeedMetadata.cs
index e8f558e..8457cb4 100644
--- a/src/Podsync/Services/Storage/FeedMetadata.cs
+++ b/src/Podsync/Services/Storage/FeedMetadata.cs
@@ -3,11 +3,11 @@ using Podsync.Services.Resolver;
 
 namespace Podsync.Services.Storage
 {
-    public struct FeedMetadata
+    public class FeedMetadata
     {
         public Provider Provider { get; set; }
 
-        public LinkType LinkType { get; set; }
+        public LinkType Type { get; set; }
 
         public string Id { get; set; }
 
@@ -16,5 +16,12 @@ namespace Podsync.Services.Storage
         public int PageSize { get; set; }
 
         public override string ToString() => $"{Provider} ({LinkType}) {Id}";
+
+        // Workaround for backward compatibility
+        public LinkType LinkType
+        {
+            get { return Type; }
+            set { Type = value; }
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Storage/RedisStorage.cs b/src/Podsync/Services/Storage/RedisStorage.cs
index e0da5de..60b2f8d 100644
--- a/src/Podsync/Services/Storage/RedisStorage.cs
+++ b/src/Podsync/Services/Storage/RedisStorage.cs
@@ -1,13 +1,14 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Net;
+using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using HashidsNet;
 using Microsoft.Extensions.Options;
-using Podsync.Services.Links;
-using Podsync.Services.Resolver;
 using StackExchange.Redis;
 
 namespace Podsync.Services.Storage
@@ -18,16 +19,6 @@ namespace Podsync.Services.Storage
         private const string IdSalt = "65fce519433f4218aa0cee6394225eea";
         private const int IdLength = 4;
 
-        // Store all fields manually for backward compatibility with existing implementation
-        private const string ProviderField = "provider";
-        private const string TypeField = "type";
-        private const string IdField = "id";
-        private const string QualityField = "quality";
-        private const string PageSizeField = "pageSize";
-
-        private const ResolveType DefaultQuality = ResolveType.VideoHigh;
-        private const int DefaultPageSize = 50;
-
         private static readonly IHashids HashIds = new Hashids(IdSalt, IdLength);
 
         private readonly string _cs;
@@ -85,13 +76,21 @@ namespace Podsync.Services.Storage
         {
             var id = await MakeId();
 
+            if (await Db.KeyExistsAsync(id))
+            {
+                throw new InvalidOperationException("Failed to generate feed id");
+            }
+
             await Db.HashSetAsync(id, new[]
             {
-                new HashEntry(ProviderField, metadata.Provider.ToString()),
-                new HashEntry(TypeField, metadata.LinkType.ToString()),
-                new HashEntry(IdField, metadata.Id),
-                new HashEntry(QualityField, metadata.Quality.ToString()),
-                new HashEntry(PageSizeField, metadata.PageSize), 
+                // V1
+                new HashEntry(nameof(metadata.Provider), metadata.Provider.ToString()),
+                new HashEntry(nameof(metadata.Type), metadata.Type.ToString()),
+                new HashEntry(nameof(metadata.Id), metadata.Id),
+
+                // V2
+                new HashEntry(nameof(metadata.Quality), metadata.Quality.ToString()),
+                new HashEntry(nameof(metadata.PageSize), metadata.PageSize),
             });
 
             await Db.KeyExpireAsync(id, TimeSpan.FromDays(1));
@@ -116,42 +115,71 @@ namespace Podsync.Services.Storage
                 throw new KeyNotFoundException("Invaid key");
             }
 
-            var metadata = new FeedMetadata
-            {
-                Id = entries.Single(x => x.Name == IdField).Value,
-                LinkType = ToEnum<LinkType>(entries.Single(x => x.Name == TypeField)),
-                Provider = ToEnum<Provider>(entries.Single(x => x.Name == ProviderField)),
-            };
+            var metadata = new FeedMetadata();
 
-            if (entries.Length > 3)
-            {
-                metadata.Quality = ToEnum<ResolveType>(entries.Single(x => x.Name == QualityField));
-                metadata.PageSize = (int)entries.Single(x => x.Name == PageSizeField).Value;
-            }
-            else
-            {
-                // Set default values
-                metadata.Quality = DefaultQuality;
-                metadata.PageSize = DefaultPageSize;
-            }
+            // V1
+            SetProperty(metadata, x => x.Id, entries);
+            SetProperty(metadata, x => x.Type, entries);
+            SetProperty(metadata, x => x.Provider, entries);
+
+            // V2
+            SetProperty(metadata, x => x.Quality, entries, Constants.DefaultFormat);
+            SetProperty(metadata, x => x.PageSize, entries, Constants.DefaultPageSize);
 
             return metadata;
         }
 
-        public Task ResetCounter()
-        {
-            return Db.KeyDeleteAsync(IdKey);
-        }
-
         public async Task<string> MakeId()
         {
             var id = await Db.StringIncrementAsync(IdKey);
             return HashIds.EncodeLong(id);
         }
 
-        private static T ToEnum<T>(HashEntry key)
+        private static void SetProperty<T, P>(T target, Expression<Func<T, P>> memberLamda, HashEntry[] entries)
         {
-            return (T)Enum.Parse(typeof(T), key.Value, true);
+            SetProperty(target, memberLamda, entries, default(P), true);
+        }
+
+        private static void SetProperty<T, P>(T target, Expression<Func<T, P>> memberLamda, HashEntry[] entries, P fallback, bool throwIfMissing = false)
+        {
+            var memberExpression = memberLamda.Body as MemberExpression;
+
+            // Get property name via reflection
+            var entryName = memberExpression?.Member?.Name;
+            if (string.IsNullOrEmpty(entryName))
+            {
+                throw new InvalidOperationException("Wrong property expression");
+            }
+
+            P value;
+
+            // RedisValue is value type
+            if (entries.Any(x => string.Equals(x.Name, entryName, StringComparison.OrdinalIgnoreCase)))
+            {
+                var entry = entries.Single(x => string.Equals(x.Name, entryName, StringComparison.OrdinalIgnoreCase));
+
+                var propertyType = typeof(P);
+                if (propertyType.GetTypeInfo().IsEnum)
+                {
+                    value = (P)Enum.Parse(propertyType, entry.Value);
+                }
+                else
+                {
+                    value = (P)Convert.ChangeType(entry.Value, propertyType);
+                }
+            }
+            else
+            {
+                if (throwIfMissing)
+                {
+                    throw new InvalidDataException("Missing mandatory property");
+                }
+
+                value = fallback;
+            }
+
+            var property = memberExpression.Member as PropertyInfo;
+            property?.SetValue(target, value);
         }
     }
 }
\ No newline at end of file
diff --git a/test/Podsync.Tests/Services/Storage/RedisStorageTests.cs b/test/Podsync.Tests/Services/Storage/RedisStorageTests.cs
index 6e0c799..3c78ef5 100644
--- a/test/Podsync.Tests/Services/Storage/RedisStorageTests.cs
+++ b/test/Podsync.Tests/Services/Storage/RedisStorageTests.cs
@@ -29,17 +29,11 @@ namespace Podsync.Tests.Services.Storage
         {
             const int idCount = 50;
 
-            try
-            {
-                var results = new string[idCount];
-                Parallel.For(0, results.Length, (i, _) => results[i] = _storage.MakeId().GetAwaiter().GetResult());
 
-                Assert.Equal(results.Length, results.Distinct().Count());
-            }
-            finally
-            {
-                _storage.ResetCounter();
-            }
+            var results = new string[idCount];
+            Parallel.For(0, results.Length, (i, _) => results[i] = _storage.MakeId().GetAwaiter().GetResult());
+
+            Assert.Equal(results.Length, results.Distinct().Count());
         }
 
         [Fact]
@@ -49,7 +43,9 @@ namespace Podsync.Tests.Services.Storage
             {
                 Id = "123",
                 LinkType = LinkType.Channel,
-                Provider = Provider.Vimeo
+                Provider = Provider.Vimeo,
+
+                PageSize = 45
             };
 
             var id = await _storage.Save(feed);
@@ -61,6 +57,7 @@ namespace Podsync.Tests.Services.Storage
             Assert.Equal(feed.Id, loaded.Id);
             Assert.Equal(feed.LinkType, loaded.LinkType);
             Assert.Equal(feed.Provider, loaded.Provider);
+            Assert.Equal(45, loaded.PageSize);
         }
 
         [Fact]

From c2292f376f2004776092b42683ea3957f050fe1d Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Fri, 6 Jan 2017 17:49:43 -0800
Subject: [PATCH 10/12] Fix unit test

---
 test/Podsync.Tests/Services/Links/LinkServiceTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/Podsync.Tests/Services/Links/LinkServiceTests.cs b/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
index 04af068..fd124d7 100644
--- a/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
+++ b/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
@@ -54,7 +54,7 @@ namespace Podsync.Tests.Services.Links
         [InlineData(Provider.YouTube, LinkType.Video, "321", "https://youtube.com/watch?v=321")]
         [InlineData(Provider.Vimeo, LinkType.Channel, "yzx", "https://vimeo.com/channels/yzx")]
         [InlineData(Provider.Vimeo, LinkType.Group, "zyd", "https://vimeo.com/groups/zyd")]
-        [InlineData(Provider.Vimeo, LinkType.User, "dfz", "https://vimeo.com/dfz")]
+        [InlineData(Provider.Vimeo, LinkType.User, "123", "https://vimeo.com/user123")]
         public void MakeLinkTest(Provider provider, LinkType linkType, string id, string expected)
         {
             var info = new LinkInfo

From dcfe1f6fc12a07a2d8f2f18de9b5870e190ba3e9 Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Fri, 6 Jan 2017 18:06:17 -0800
Subject: [PATCH 11/12] Merge constants

---
 src/Podsync/Helpers/Extensions.cs                |  4 ++--
 src/Podsync/Services/Constants.cs                | 11 +++++++++++
 src/Podsync/Services/Patreon/PatreonConstants.cs | 13 -------------
 src/Podsync/Startup.cs                           | 10 +++++-----
 4 files changed, 18 insertions(+), 20 deletions(-)
 delete mode 100644 src/Podsync/Services/Patreon/PatreonConstants.cs

diff --git a/src/Podsync/Helpers/Extensions.cs b/src/Podsync/Helpers/Extensions.cs
index 90c99ed..7e175ad 100644
--- a/src/Podsync/Helpers/Extensions.cs
+++ b/src/Podsync/Helpers/Extensions.cs
@@ -3,7 +3,7 @@ using System.Linq;
 using System.Security.Claims;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
-using Podsync.Services.Patreon;
+using Podsync.Services;
 
 namespace Podsync.Helpers
 {
@@ -53,7 +53,7 @@ namespace Podsync.Helpers
             const int MinAmountCents = 100;
 
             int amount;
-            if (int.TryParse(user.GetClaim(PatreonConstants.AmountDonated), out amount))
+            if (int.TryParse(user.GetClaim(Constants.Patreon.AmountDonated), out amount))
             {
                 return amount >= MinAmountCents;
             }
diff --git a/src/Podsync/Services/Constants.cs b/src/Podsync/Services/Constants.cs
index e5ab7cd..1e28c9f 100644
--- a/src/Podsync/Services/Constants.cs
+++ b/src/Podsync/Services/Constants.cs
@@ -7,5 +7,16 @@ namespace Podsync.Services
         public const int DefaultPageSize = 50;
 
         public const ResolveType DefaultFormat = ResolveType.VideoHigh;
+
+        public static class Patreon
+        {
+            public const string AuthenticationScheme = "Patreon";
+
+            public const string AuthorizationEndpoint = "https://www.patreon.com/oauth2/authorize";
+
+            public const string TokenEndpoint = "https://api.patreon.com/oauth2/token";
+
+            public const string AmountDonated = "Patreon/" + nameof(AmountDonated);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/Podsync/Services/Patreon/PatreonConstants.cs b/src/Podsync/Services/Patreon/PatreonConstants.cs
deleted file mode 100644
index ae968ca..0000000
--- a/src/Podsync/Services/Patreon/PatreonConstants.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-namespace Podsync.Services.Patreon
-{
-    public static class PatreonConstants
-    {
-        public const string AuthenticationScheme = "Patreon";
-
-        public const string AuthorizationEndpoint = "https://www.patreon.com/oauth2/authorize";
-
-        public const string TokenEndpoint = "https://api.patreon.com/oauth2/token";
-
-        public const string AmountDonated = "Patreon/" + nameof(AmountDonated);
-    }
-}
\ No newline at end of file
diff --git a/src/Podsync/Startup.cs b/src/Podsync/Startup.cs
index c8dc8dd..4349439 100644
--- a/src/Podsync/Startup.cs
+++ b/src/Podsync/Startup.cs
@@ -95,15 +95,15 @@ namespace Podsync
             // Patreon authentication
             app.UseOAuthAuthentication(new OAuthOptions
             {
-                AuthenticationScheme = PatreonConstants.AuthenticationScheme,
+                AuthenticationScheme = Constants.Patreon.AuthenticationScheme,
 
                 ClientId = Configuration[$"Podsync:{nameof(PodsyncConfiguration.PatreonClientId)}"],
                 ClientSecret = Configuration[$"Podsync:{nameof(PodsyncConfiguration.PatreonSecret)}"],
 
                 CallbackPath = new PathString("/oauth-patreon"),
 
-                AuthorizationEndpoint = PatreonConstants.AuthorizationEndpoint,
-                TokenEndpoint = PatreonConstants.TokenEndpoint,
+                AuthorizationEndpoint = Constants.Patreon.AuthorizationEndpoint,
+                TokenEndpoint = Constants.Patreon.TokenEndpoint,
 
                 SaveTokens = true,
 
@@ -129,7 +129,7 @@ namespace Podsync
                         context.Identity.AddClaim(new Claim(ClaimTypes.Uri, user.Url));
 
                         var amountCents = user.Pledges.Sum(x => x.AmountCents);
-                        context.Identity.AddClaim(new Claim(PatreonConstants.AmountDonated, amountCents.ToString()));
+                        context.Identity.AddClaim(new Claim(Constants.Patreon.AmountDonated, amountCents.ToString()));
 
                         var telemetry = app.ApplicationServices.GetService<TelemetryClient>();
                         telemetry.TrackEvent("Login", new Dictionary<string, string>
@@ -147,7 +147,7 @@ namespace Podsync
                 builder.Run(async context =>
                 {
                     // Return a challenge to invoke the Patreon authentication scheme
-                    await context.Authentication.ChallengeAsync(PatreonConstants.AuthenticationScheme, new AuthenticationProperties { RedirectUri = "/" });
+                    await context.Authentication.ChallengeAsync(Constants.Patreon.AuthenticationScheme, new AuthenticationProperties { RedirectUri = "/" });
                 });
             });
 

From 6d926a3d0185b0a304ae5a0293f14bf41f5086bb Mon Sep 17 00:00:00 2001
From: Maksym Pavlenko <pavlenko.maksym@gmail.com>
Date: Mon, 9 Jan 2017 10:34:08 -0800
Subject: [PATCH 12/12] Add a few additional test cases for YouTube links

---
 test/Podsync.Tests/Services/Links/LinkServiceTests.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/Podsync.Tests/Services/Links/LinkServiceTests.cs b/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
index fd124d7..c7ff3b4 100644
--- a/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
+++ b/test/Podsync.Tests/Services/Links/LinkServiceTests.cs
@@ -15,6 +15,8 @@ namespace Podsync.Tests.Services.Links
         [InlineData("https://www.youtube.com/user/UC5XPnUk8Vvv_pWslhwom6Og", LinkType.User, "UC5XPnUk8Vvv_pWslhwom6Og")]
         [InlineData("https://www.youtube.com/user/ComboBreakerVideo/videos", LinkType.User, "ComboBreakerVideo")]
         [InlineData("https://www.youtube.com/user/UC5XPnUk8Vvv_pWslhwom6Og/playlists", LinkType.User, "UC5XPnUk8Vvv_pWslhwom6Og")]
+        [InlineData("https://www.youtube.com/playlist?list=PLP8qlV2aurYqdhyXW9ErqUW9Fw9F_mheM", LinkType.Playlist, "PLP8qlV2aurYqdhyXW9ErqUW9Fw9F_mheM")]
+        [InlineData("https://www.youtube.com/user/NEMAGIA/videos", LinkType.User, "NEMAGIA")]
         public void ParseYoutubeLinks(string link, LinkType linkType, string id)
         {
             var info = _linkService.Parse(new Uri(link));