open-source-mirrors
/
Ombi
mirror of https://github.com/Ombi-app/Ombi
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

#150 start caching plex media as well. refactored the availability checker. NEEDS TESTING. also, we need to make the Requests hit the plex api directly rather than hitting the cache as it does now.

Browse Source
pull/158/head
Drewster727 9 years ago
parent e707837bf5
commit 718e8868c1
16 changed files with 800 additions and 593 deletions
Show Stats Download Patch File Download Diff File

2
PlexRequests.Api.Interfaces/IPlexApi.cs
Unescape View File

@ -38,5 +38,7 @@ namespace PlexRequests.Api.Interfaces
PlexSearch SearchContent(string authToken, string searchTerm, Uri plexFullHost); PlexSearch SearchContent(string authToken, string searchTerm, Uri plexFullHost);
PlexStatus GetStatus(string authToken, Uri uri); PlexStatus GetStatus(string authToken, Uri uri);
PlexAccount GetAccount(string authToken); PlexAccount GetAccount(string authToken);
PlexLibraries GetLibrarySections(string authToken, Uri plexFullHost);
PlexSearch GetLibrary(string authToken, Uri plexFullHost, string libraryId);
} }
} }

22
PlexRequests.Api.Models/Plex/PlexLibraries.cs
Unescape View File

@ -0,0 +1,22 @@
using System.Collections.Generic;
using System.Xml.Serialization;
namespace PlexRequests.Api.Models.Plex
{
[XmlRoot(ElementName = "MediaContainer")]
public class PlexLibraries
{
[XmlElement(ElementName = "Directory")]
public List<Directory> Directories { get; set; }
}
[XmlRoot(ElementName = "Location")]
public partial class Location
{
[XmlElement(ElementName = "id")]
public int id { get; set; }
[XmlElement(ElementName = "path")]
public string path { get; set; }
}
}

35
PlexRequests.Api.Models/Plex/PlexMediaType.cs
Unescape View File

@ -0,0 +1,35 @@
#region Copyright
// /************************************************************************
// Copyright (c) 2016 Jamie Rees
// File: PlexType.cs
// Created By: Jamie Rees
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// ************************************************************************/
#endregion
namespace PlexRequests.Services
{
public enum PlexMediaType
{
Movie,
Show,
Music // double check this one
}
}

2
PlexRequests.Api.Models/Plex/PlexStatus.cs
Unescape View File

@ -16,6 +16,8 @@ namespace PlexRequests.Api.Models.Plex
public string Key { get; set; } public string Key { get; set; }
[XmlAttribute(AttributeName = "title")] [XmlAttribute(AttributeName = "title")]
public string Title { get; set; } public string Title { get; set; }
[XmlAttribute(AttributeName = "type")]
public string type { get; set; }
} }
[XmlRoot(ElementName = "MediaContainer")] [XmlRoot(ElementName = "MediaContainer")]

2
PlexRequests.Api.Models/PlexRequests.Api.Models.csproj
Unescape View File

@ -63,8 +63,10 @@
<Compile Include="Plex\PlexAuthentication.cs" /> <Compile Include="Plex\PlexAuthentication.cs" />
<Compile Include="Plex\PlexError.cs" /> <Compile Include="Plex\PlexError.cs" />
<Compile Include="Plex\PlexFriends.cs" /> <Compile Include="Plex\PlexFriends.cs" />
<Compile Include="Plex\PlexLibraries.cs" />
<Compile Include="Plex\PlexSearch.cs" /> <Compile Include="Plex\PlexSearch.cs" />
<Compile Include="Plex\PlexStatus.cs" /> <Compile Include="Plex\PlexStatus.cs" />
<Compile Include="Plex\PlexMediaType.cs" />
<Compile Include="Plex\PlexUserRequest.cs" /> <Compile Include="Plex\PlexUserRequest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" /> <Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="SickRage\SickRageBase.cs" /> <Compile Include="SickRage\SickRageBase.cs" />

80
PlexRequests.Api/PlexApi.cs
Unescape View File

@ -32,6 +32,8 @@ using PlexRequests.Api.Models.Plex;
using PlexRequests.Helpers; using PlexRequests.Helpers;
using RestSharp; using RestSharp;
using System.Xml;
using System.Collections.Generic;
namespace PlexRequests.Api namespace PlexRequests.Api
{ {
@ -58,10 +60,7 @@ namespace PlexRequests.Api
Method = Method.POST Method = Method.POST
}; };
request.AddHeader("X-Plex-Client-Identifier", "Test213"); // TODO need something unique to the users version/installation AddHeaders(ref request);
request.AddHeader("X-Plex-Product", "Request Plex");
request.AddHeader("X-Plex-Version", Version);
request.AddHeader("Content-Type", "application/json");
request.AddJsonBody(userModel); request.AddJsonBody(userModel);
@ -76,11 +75,7 @@ namespace PlexRequests.Api
Method = Method.GET, Method = Method.GET,
}; };
request.AddHeader("X-Plex-Client-Identifier", "Test213"); AddHeaders(ref request, authToken);
request.AddHeader("X-Plex-Product", "Request Plex");
request.AddHeader("X-Plex-Version", Version);
request.AddHeader("X-Plex-Token", authToken);
request.AddHeader("Content-Type", "application/xml");
var api = new ApiRequest(); var api = new ApiRequest();
var users = api.ExecuteXml<PlexFriends>(request, new Uri("https://plex.tv/pms/friends/all")); var users = api.ExecuteXml<PlexFriends>(request, new Uri("https://plex.tv/pms/friends/all"));
@ -104,11 +99,7 @@ namespace PlexRequests.Api
}; };
request.AddUrlSegment("searchTerm", searchTerm); request.AddUrlSegment("searchTerm", searchTerm);
request.AddHeader("X-Plex-Client-Identifier", "Test213"); AddHeaders(ref request, authToken);
request.AddHeader("X-Plex-Product", "Request Plex");
request.AddHeader("X-Plex-Version", Version);
request.AddHeader("X-Plex-Token", authToken);
request.AddHeader("Content-Type", "application/xml");
var api = new ApiRequest(); var api = new ApiRequest();
var search = api.ExecuteXml<PlexSearch>(request, plexFullHost); var search = api.ExecuteXml<PlexSearch>(request, plexFullHost);
@ -123,11 +114,7 @@ namespace PlexRequests.Api
Method = Method.GET, Method = Method.GET,
}; };
request.AddHeader("X-Plex-Client-Identifier", "Test213"); AddHeaders(ref request, authToken);
request.AddHeader("X-Plex-Product", "Request Plex");
request.AddHeader("X-Plex-Version", Version);
request.AddHeader("X-Plex-Token", authToken);
request.AddHeader("Content-Type", "application/xml");
var api = new ApiRequest(); var api = new ApiRequest();
var users = api.ExecuteXml<PlexStatus>(request, uri); var users = api.ExecuteXml<PlexStatus>(request, uri);
@ -142,17 +129,62 @@ namespace PlexRequests.Api
Method = Method.GET, Method = Method.GET,
}; };
request.AddHeader("X-Plex-Client-Identifier", "Test213"); AddHeaders(ref request, authToken);
request.AddHeader("X-Plex-Product", "Request Plex");
request.AddHeader("X-Plex-Version", Version);
request.AddHeader("X-Plex-Token", authToken);
request.AddHeader("Content-Type", "application/xml");
var api = new ApiRequest(); var api = new ApiRequest();
var account = api.ExecuteXml<PlexAccount>(request, new Uri("https://plex.tv/users/account")); var account = api.ExecuteXml<PlexAccount>(request, new Uri("https://plex.tv/users/account"));
return account; return account;
} }
public PlexLibraries GetLibrarySections(string authToken, Uri plexFullHost)
{
var request = new RestRequest
{
Method = Method.GET,
Resource = "library/sections"
};
AddHeaders(ref request, authToken);
var api = new ApiRequest();
var sections = api.ExecuteXml<PlexLibraries>(request, plexFullHost);
var x = GetLibrary(authToken, plexFullHost, sections.Directories[0].Key);
return sections;
}
public PlexSearch GetLibrary(string authToken, Uri plexFullHost, string libraryId)
{
var request = new RestRequest
{
Method = Method.GET,
Resource = "library/sections/{libraryId}/all"
};
request.AddUrlSegment("libraryId", libraryId.ToString());
AddHeaders(ref request, authToken);
var api = new ApiRequest();
var search = api.ExecuteXml<PlexSearch>(request, plexFullHost);
return search;
}
private void AddHeaders(ref RestRequest request, string authToken)
{
request.AddHeader("X-Plex-Token", authToken);
AddHeaders(ref request);
}
private void AddHeaders(ref RestRequest request)
{
request.AddHeader("X-Plex-Client-Identifier", "Test213");
request.AddHeader("X-Plex-Product", "Request Plex");
request.AddHeader("X-Plex-Version", Version);
request.AddHeader("Content-Type", "application/xml");
}
} }
} }

2
PlexRequests.Core/CacheKeys.cs
Unescape View File

@ -28,6 +28,8 @@ namespace PlexRequests.Core
{ {
public class CacheKeys public class CacheKeys
{ {
public const string PlexLibaries = "PlexLibaries";
public const string TvDbToken = "TheTvDbApiToken"; public const string TvDbToken = "TheTvDbApiToken";
public const string SonarrQualityProfiles = "SonarrQualityProfiles"; public const string SonarrQualityProfiles = "SonarrQualityProfiles";

917
PlexRequests.Services.Tests/PlexAvailabilityCheckerTests.cs
Unescape View File

@ -38,6 +38,7 @@ using PlexRequests.Core.SettingModels;
using PlexRequests.Helpers.Exceptions; using PlexRequests.Helpers.Exceptions;
using PlexRequests.Services.Interfaces; using PlexRequests.Services.Interfaces;
using PlexRequests.Store; using PlexRequests.Store;
using PlexRequests.Helpers;
namespace PlexRequests.Services.Tests namespace PlexRequests.Services.Tests
{ {
@ -46,502 +47,524 @@ namespace PlexRequests.Services.Tests
{ {
public IAvailabilityChecker Checker { get; set; } public IAvailabilityChecker Checker { get; set; }
[Test] //[Test]
public void IsAvailableWithEmptySettingsTest() //public void IsAvailableWithEmptySettingsTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // var cacheMock = new Mock<ICacheProvider>();
// Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
Assert.Throws<ApplicationSettingsException>(() => Checker.IsAvailable("title", "2013", null, PlexType.TvShow), "We should be throwing an exception since we cannot talk to the services."); // Assert.Throws<ApplicationSettingsException>(() => Checker.IsAvailable("title", "2013", null, PlexType.TvShow), "We should be throwing an exception since we cannot talk to the services.");
} //}
[Test] //[Test]
public void IsAvailableTest() //public void IsAvailableTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title", Year = "2011" } } }; // var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title", Year = "2011" } } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", "2011", null, PlexType.Movie); // var result = Checker.IsAvailable("title", "2011", null, PlexType.Movie);
Assert.That(result, Is.True); // Assert.That(result, Is.True);
} //}
[Test] //[Test]
public void IsAvailableMusicDirectoryTitleTest() //public void IsAvailableMusicDirectoryTitleTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Directory = new List<Directory1> { new Directory1 { Title = "title", Year = "2013", ParentTitle = "dIzZy"} } }; // var searchResult = new PlexSearch { Directory = new List<Directory1> { new Directory1 { Title = "title", Year = "2013", ParentTitle = "dIzZy"} } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", "2013", "dIzZy", PlexType.Music); // var result = Checker.IsAvailable("title", "2013", "dIzZy", PlexType.Music);
Assert.That(result, Is.True); // Assert.That(result, Is.True);
} //}
[Test] //[Test]
public void IsNotAvailableMusicDirectoryTitleTest() //public void IsNotAvailableMusicDirectoryTitleTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Directory = new List<Directory1> { new Directory1 { Title = "titale2", Year = "1992", ParentTitle = "dIzZy" } } }; // var searchResult = new PlexSearch { Directory = new List<Directory1> { new Directory1 { Title = "titale2", Year = "1992", ParentTitle = "dIzZy" } } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", "2013", "dIzZy", PlexType.Music); // var result = Checker.IsAvailable("title", "2013", "dIzZy", PlexType.Music);
Assert.That(result, Is.False); // Assert.That(result, Is.False);
} //}
[Test] //[Test]
public void IsAvailableDirectoryTitleWithoutYearTest() //public void IsAvailableDirectoryTitleWithoutYearTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Directory = new List<Directory1> { new Directory1 { Title = "title", } } }; // var searchResult = new PlexSearch { Directory = new List<Directory1> { new Directory1 { Title = "title", } } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", null, null, PlexType.Movie); // var result = Checker.IsAvailable("title", null, null, PlexType.Movie);
Assert.That(result, Is.True); // Assert.That(result, Is.True);
} //}
[Test] //[Test]
public void IsNotAvailableTest() //public void IsNotAvailableTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "wrong title", Year = "2011" } } }; // var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "wrong title", Year = "2011" } } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", "2011", null, PlexType.Movie); // var result = Checker.IsAvailable("title", "2011", null, PlexType.Movie);
Assert.That(result, Is.False); // Assert.That(result, Is.False);
} //}
[Test] //[Test]
public void IsNotAvailableTestWihtoutYear() //public void IsNotAvailableTestWihtoutYear()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "wrong title" } } }; // var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "wrong title" } } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", null, null, PlexType.Movie); // var result = Checker.IsAvailable("title", null, null, PlexType.Movie);
Assert.That(result, Is.False); // Assert.That(result, Is.False);
} //}
[Test] //[Test]
public void IsYearDoesNotMatchTest() //public void IsYearDoesNotMatchTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title", Year = "2019" } } }; // var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title", Year = "2019" } } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", "2011", null, PlexType.Movie); // var result = Checker.IsAvailable("title", "2011", null, PlexType.Movie);
Assert.That(result, Is.False); // Assert.That(result, Is.False);
} //}
[Test] //[Test]
public void TitleDoesNotMatchTest() //public void TitleDoesNotMatchTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title23", Year = "2019" } } }; // var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title23", Year = "2019" } } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", "2019", null, PlexType.Movie); // var result = Checker.IsAvailable("title", "2019", null, PlexType.Movie);
Assert.That(result, Is.False); // Assert.That(result, Is.False);
} //}
[Test] //[Test]
public void TitleDoesNotMatchWithoutYearTest() //public void TitleDoesNotMatchWithoutYearTest()
{ //{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); // var requestMock = new Mock<IRequestService>();
var plexMock = new Mock<IPlexApi>(); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title23" } } };
// var searchResult = new PlexSearch { Video = new List<Video> { new Video { Title = "title23" } } };
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "abc" });
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
// plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(searchResult);
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object);
// Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
var result = Checker.IsAvailable("title", null, null, PlexType.Movie);
// var result = Checker.IsAvailable("title", null, null, PlexType.Movie);
Assert.That(result, Is.False);
} // Assert.That(result, Is.False);
//}
[Test]
public void CheckAndUpdateNoPlexSettingsTest() //[Test]
{ //public void CheckAndUpdateNoPlexSettingsTest()
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); //{
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
var requestMock = new Mock<IRequestService>(); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var plexMock = new Mock<IPlexApi>(); // var requestMock = new Mock<IRequestService>();
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // var plexMock = new Mock<IPlexApi>();
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // var cacheMock = new Mock<ICacheProvider>();
Checker.CheckAndUpdateAll(1); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
// Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Never);
requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never); // Checker.CheckAndUpdateAll(1);
plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Never);
} // requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Never);
// requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never);
[Test] // plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Never);
public void CheckAndUpdateNoAuthSettingsTest() //}
{
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); //[Test]
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); //public void CheckAndUpdateNoAuthSettingsTest()
var requestMock = new Mock<IRequestService>(); //{
var plexMock = new Mock<IPlexApi>(); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "123" }); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
// var requestMock = new Mock<IRequestService>();
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
Checker.CheckAndUpdateAll(1);
// settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "123" });
requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Never);
requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never); // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Never);
} // Checker.CheckAndUpdateAll(1);
[Test] // requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Never);
public void CheckAndUpdateNoRequestsTest() // requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never);
{ // plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Never);
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); //}
var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
var requestMock = new Mock<IRequestService>(); //[Test]
var plexMock = new Mock<IPlexApi>(); //public void CheckAndUpdateNoRequestsTest()
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "192.168.1.1" }); //{
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
requestMock.Setup(x => x.GetAll()).Returns(new List<RequestedModel>()); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
// var requestMock = new Mock<IRequestService>();
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
Checker.CheckAndUpdateAll(1);
// settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "192.168.1.1" });
requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Never); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never); // requestMock.Setup(x => x.GetAll()).Returns(new List<RequestedModel>());
plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Never);
} // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
// Checker.CheckAndUpdateAll(1);
[Test]
public void CheckAndUpdateRequestsThatDoNotExistInPlexTest() // requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Never);
{ // requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never);
// plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Never);
var requests = new List<RequestedModel> { //}
new RequestedModel
{
Id = 123, //[Test]
Title = "title1", //public void CheckAndUpdateRequestsThatDoNotExistInPlexTest()
Available = false, //{
},
new RequestedModel // var requests = new List<RequestedModel> {
{ // new RequestedModel
Id=222, // {
Title = "title3", // Id = 123,
Available = false // Title = "title1",
}, // Available = false,
new RequestedModel // },
{ // new RequestedModel
Id = 333, // {
Title= "missingTitle", // Id=222,
Available = false // Title = "title3",
}, // Available = false
new RequestedModel // },
{ // new RequestedModel
Id= 444, // {
Title = "already found", // Id = 333,
Available = true // Title= "missingTitle",
} // Available = false
}; // },
// new RequestedModel
var search = new PlexSearch // {
{ // Id= 444,
Video = new List<Video> // Title = "already found",
{ // Available = true
new Video // }
{ // };
Title = "Title4",
Year = "2012" // var search = new PlexSearch
}, // {
new Video // Video = new List<Video>
{ // {
Title = "Title2", // new Video
} // {
}, // Title = "Title4",
Directory = new List<Directory1> { new Directory1 // Year = "2012"
{ // },
Title = "Title9", // new Video
Year = "1978" // {
}} // Title = "Title2",
}; // }
// },
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // Directory = new List<Directory1> { new Directory1
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // {
var requestMock = new Mock<IRequestService>(); // Title = "Title9",
var plexMock = new Mock<IPlexApi>(); // Year = "1978"
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "192.168.1.1" }); // }}
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // };
requestMock.Setup(x => x.GetAll()).Returns(requests);
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(search); // var settingsMock = new Mock<ISettingsService<PlexSettings>>();
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
// var requestMock = new Mock<IRequestService>();
Checker.CheckAndUpdateAll(1); // var plexMock = new Mock<IPlexApi>();
// var cacheMock = new Mock<ICacheProvider>();
requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Never);
requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never); // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "192.168.1.1" });
plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Exactly(3)); // authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
} // requestMock.Setup(x => x.GetAll()).Returns(requests);
// plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(search);
[Test] // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
public void CheckAndUpdateRequestsAllRequestsTest()
{ // Checker.CheckAndUpdateAll(1);
var requests = new List<RequestedModel> { // requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Never);
new RequestedModel // requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never);
{ // plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Exactly(3));
Id = 123, //}
Title = "title1",
Available = false, //[Test]
}, //public void CheckAndUpdateRequestsAllRequestsTest()
new RequestedModel //{
{
Id=222, // var requests = new List<RequestedModel> {
Title = "title3", // new RequestedModel
Available = false // {
}, // Id = 123,
new RequestedModel // Title = "title1",
{ // Available = false,
Id = 333, // },
Title= "missingTitle", // new RequestedModel
Available = false // {
}, // Id=222,
new RequestedModel // Title = "title3",
{ // Available = false
Id= 444, // },
Title = "Hi", // new RequestedModel
Available = false // {
} // Id = 333,
}; // Title= "missingTitle",
// Available = false
var search = new PlexSearch // },
{ // new RequestedModel
Video = new List<Video> // {
{ // Id= 444,
new Video // Title = "Hi",
{ // Available = false
Title = "title1", // }
Year = "2012" // };
},
new Video // var search = new PlexSearch
{ // {
Title = "Title3", // Video = new List<Video>
} // {
, // new Video
new Video // {
{ // Title = "title1",
Title = "Hi", // Year = "2012"
} // },
}, // new Video
Directory = new List<Directory1> { new Directory1 // {
{ // Title = "Title3",
Title = "missingTitle", // }
Year = "1978" // ,
}} // new Video
}; // {
// Title = "Hi",
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // }
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // },
var requestMock = new Mock<IRequestService>(); // Directory = new List<Directory1> { new Directory1
var plexMock = new Mock<IPlexApi>(); // {
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "192.168.1.1" }); // Title = "missingTitle",
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // Year = "1978"
requestMock.Setup(x => x.GetAll()).Returns(requests); // }}
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(search); // };
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object);
// var settingsMock = new Mock<ISettingsService<PlexSettings>>();
Checker.CheckAndUpdateAll(1); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
// var requestMock = new Mock<IRequestService>();
requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Once); // var plexMock = new Mock<IPlexApi>();
requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never); // var cacheMock = new Mock<ICacheProvider>();
plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Exactly(4));
} // settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "192.168.1.1" });
// authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
// requestMock.Setup(x => x.GetAll()).Returns(requests);
[Test] // plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(search);
public void CheckAndUpdateAllMusicRequestsTest() // Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
{
// Checker.CheckAndUpdateAll(1);
var requests = new List<RequestedModel> {
new RequestedModel // requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Once);
{ // requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never);
Id = 123, // plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Exactly(4));
Title = "title1", //}
Available = false,
ArtistName = "dizzy",
Type = RequestType.Album, //[Test]
ReleaseDate = new DateTime(2010,1,1) //public void CheckAndUpdateAllMusicRequestsTest()
}, //{
new RequestedModel
{ // var requests = new List<RequestedModel> {
Id=222, // new RequestedModel
Title = "title3", // {
Available = false, // Id = 123,
ArtistName = "a", // Title = "title1",
Type = RequestType.Album, // Available = false,
ReleaseDate = new DateTime(2006,1,1) // ArtistName = "dizzy",
}, // Type = RequestType.Album,
new RequestedModel // ReleaseDate = new DateTime(2010,1,1)
{ // },
Id = 333, // new RequestedModel
Title= "missingTitle", // {
Available = false, // Id=222,
ArtistName = "b", // Title = "title3",
Type = RequestType.Album, // Available = false,
ReleaseDate = new DateTime(1992,1,1) // ArtistName = "a",
}, // Type = RequestType.Album,
new RequestedModel // ReleaseDate = new DateTime(2006,1,1)
{ // },
Id= 444, // new RequestedModel
Title = "Hi", // {
Available = false, // Id = 333,
ArtistName = "c", // Title= "missingTitle",
Type = RequestType.Album, // Available = false,
ReleaseDate = new DateTime(2017,1,1) // ArtistName = "b",
} // Type = RequestType.Album,
}; // ReleaseDate = new DateTime(1992,1,1)
// },
var search = new PlexSearch // new RequestedModel
{ // {
Directory = new List<Directory1> { // Id= 444,
new Directory1 // Title = "Hi",
{ // Available = false,
Title = "missingTitle", // ArtistName = "c",
Year = "1978", // Type = RequestType.Album,
ParentTitle = "c" // ReleaseDate = new DateTime(2017,1,1)
}, // }
new Directory1 // };
{
Title = "Hi", // var search = new PlexSearch
Year = "1978", // {
ParentTitle = "c" // Directory = new List<Directory1> {
}, // new Directory1
new Directory1 // {
{ // Title = "missingTitle",
Title = "Hi", // Year = "1978",
Year = "2017", // ParentTitle = "c"
ParentTitle = "c" // },
}, // new Directory1
new Directory1 // {
{ // Title = "Hi",
Title = "missingTitle", // Year = "1978",
Year = "1992", // ParentTitle = "c"
ParentTitle = "b" // },
}, // new Directory1
new Directory1 // {
{ // Title = "Hi",
Title = "title1", // Year = "2017",
Year = "2010", // ParentTitle = "c"
ParentTitle = "DiZzY" // },
}, // new Directory1
} // {
}; // Title = "missingTitle",
// Year = "1992",
var settingsMock = new Mock<ISettingsService<PlexSettings>>(); // ParentTitle = "b"
var authMock = new Mock<ISettingsService<AuthenticationSettings>>(); // },
var requestMock = new Mock<IRequestService>(); // new Directory1
var plexMock = new Mock<IPlexApi>(); // {
settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "192.168.1.1" }); // Title = "title1",
authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" }); // Year = "2010",
requestMock.Setup(x => x.GetAll()).Returns(requests); // ParentTitle = "DiZzY"
plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(search); // },
Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object); // }
// };
Checker.CheckAndUpdateAll(1);
// var settingsMock = new Mock<ISettingsService<PlexSettings>>();
requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Once); // var authMock = new Mock<ISettingsService<AuthenticationSettings>>();
requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never); // var requestMock = new Mock<IRequestService>();
plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Exactly(4)); // var plexMock = new Mock<IPlexApi>();
} // var cacheMock = new Mock<ICacheProvider>();
// settingsMock.Setup(x => x.GetSettings()).Returns(new PlexSettings { Ip = "192.168.1.1" });
// authMock.Setup(x => x.GetSettings()).Returns(new AuthenticationSettings { PlexAuthToken = "abc" });
// requestMock.Setup(x => x.GetAll()).Returns(requests);
// plexMock.Setup(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>())).Returns(search);
// Checker = new PlexAvailabilityChecker(settingsMock.Object, authMock.Object, requestMock.Object, plexMock.Object, cacheMock.Object);
// Checker.CheckAndUpdateAll(1);
// requestMock.Verify(x => x.BatchUpdate(It.IsAny<List<RequestedModel>>()), Times.Once);
// requestMock.Verify(x => x.Get(It.IsAny<int>()), Times.Never);
// plexMock.Verify(x => x.SearchContent(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Uri>()), Times.Exactly(4));
//}
} }
} }

4
PlexRequests.Services/AvailabilityUpdateService.cs
Unescape View File

@ -41,6 +41,7 @@ using PlexRequests.Helpers;
using PlexRequests.Services.Interfaces; using PlexRequests.Services.Interfaces;
using PlexRequests.Store; using PlexRequests.Store;
using PlexRequests.Store.Repository; using PlexRequests.Store.Repository;
using System.Threading.Tasks;
namespace PlexRequests.Services namespace PlexRequests.Services
{ {
@ -53,7 +54,7 @@ namespace PlexRequests.Services
var repo = new SettingsJsonRepository(dbConfig, memCache); var repo = new SettingsJsonRepository(dbConfig, memCache);
ConfigurationReader = new ConfigurationReader(); ConfigurationReader = new ConfigurationReader();
Checker = new PlexAvailabilityChecker(new SettingsServiceV2<PlexSettings>(repo), new SettingsServiceV2<AuthenticationSettings>(repo), new JsonRequestService(new RequestJsonRepository(dbConfig, memCache)), new PlexApi()); Checker = new PlexAvailabilityChecker(new SettingsServiceV2<PlexSettings>(repo), new SettingsServiceV2<AuthenticationSettings>(repo), new JsonRequestService(new RequestJsonRepository(dbConfig, memCache)), new PlexApi(), memCache);
HostingEnvironment.RegisterObject(this); HostingEnvironment.RegisterObject(this);
} }
@ -67,6 +68,7 @@ namespace PlexRequests.Services
{ {
UpdateSubscription?.Dispose(); UpdateSubscription?.Dispose();
Task.Factory.StartNew(() => Checker.CheckAndUpdateAll(-1)); // cache the libraries and run the availability checks
UpdateSubscription = Observable.Interval(c.Intervals.Notification).Subscribe(Checker.CheckAndUpdateAll); UpdateSubscription = Observable.Interval(c.Intervals.Notification).Subscribe(Checker.CheckAndUpdateAll);
} }

10
PlexRequests.Services/Interfaces/IAvailabilityChecker.cs
Unescape View File

@ -24,11 +24,19 @@
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// ************************************************************************/ // ************************************************************************/
#endregion #endregion
using PlexRequests.Services.Models;
using System.Collections.Generic;
namespace PlexRequests.Services.Interfaces namespace PlexRequests.Services.Interfaces
{ {
public interface IAvailabilityChecker public interface IAvailabilityChecker
{ {
void CheckAndUpdateAll(long check); void CheckAndUpdateAll(long check);
bool IsAvailable(string title, string year, string artist, PlexType type); List<PlexMovie> GetPlexMovies();
bool IsMovieAvailable(PlexMovie[] plexMovies, string title, string year);
List<PlexTvShow> GetPlexTvShows();
bool IsTvShowAvailable(PlexTvShow[] plexShows, string title, string year);
List<PlexAlbum> GetPlexAlbums();
bool IsAlbumAvailable(PlexAlbum[] plexAlbums, string title, string year, string artist);
} }
} }

9
PlexRequests.Services/Models/PlexAlbum.cs
Unescape View File

@ -0,0 +1,9 @@
namespace PlexRequests.Services.Models
{
public class PlexAlbum
{
public string Title { get; set; }
public string Artist { get; set; }
public string ReleaseYear { get; set; }
}
}

8
PlexRequests.Services/Models/PlexMovie.cs
Unescape View File

@ -0,0 +1,8 @@
namespace PlexRequests.Services.Models
{
public class PlexMovie
{
public string Title { get; set; }
public string ReleaseYear { get; set; }
}
}

8
PlexRequests.Services/Models/PlexTvShow.cs
Unescape View File

@ -0,0 +1,8 @@
namespace PlexRequests.Services.Models
{
public class PlexTvShow
{
public string Title { get; set; }
public string ReleaseYear { get; set; }
}
}

242
PlexRequests.Services/PlexAvailabilityChecker.cs
Unescape View File

@ -38,17 +38,19 @@ using PlexRequests.Helpers;
using PlexRequests.Helpers.Exceptions; using PlexRequests.Helpers.Exceptions;
using PlexRequests.Services.Interfaces; using PlexRequests.Services.Interfaces;
using PlexRequests.Store; using PlexRequests.Store;
using PlexRequests.Services.Models;
namespace PlexRequests.Services namespace PlexRequests.Services
{ {
public class PlexAvailabilityChecker : IAvailabilityChecker public class PlexAvailabilityChecker : IAvailabilityChecker
{ {
public PlexAvailabilityChecker(ISettingsService<PlexSettings> plexSettings, ISettingsService<AuthenticationSettings> auth, IRequestService request, IPlexApi plex) public PlexAvailabilityChecker(ISettingsService<PlexSettings> plexSettings, ISettingsService<AuthenticationSettings> auth, IRequestService request, IPlexApi plex, ICacheProvider cache)
{ {
Plex = plexSettings; Plex = plexSettings;
Auth = auth; Auth = auth;
RequestService = request; RequestService = request;
PlexApi = plex; PlexApi = plex;
Cache = cache;
} }
private ISettingsService<PlexSettings> Plex { get; } private ISettingsService<PlexSettings> Plex { get; }
@ -56,7 +58,7 @@ namespace PlexRequests.Services
private IRequestService RequestService { get; } private IRequestService RequestService { get; }
private static Logger Log = LogManager.GetCurrentClassLogger(); private static Logger Log = LogManager.GetCurrentClassLogger();
private IPlexApi PlexApi { get; } private IPlexApi PlexApi { get; }
private ICacheProvider Cache { get; }
public void CheckAndUpdateAll(long check) public void CheckAndUpdateAll(long check)
{ {
@ -76,48 +78,47 @@ namespace PlexRequests.Services
return; return;
} }
var libraries = CachedLibraries(authSettings, plexSettings, true); //force setting the cache (10 min intervals via scheduler)
var movies = GetPlexMovies().ToArray();
var shows = GetPlexTvShows().ToArray();
var albums = GetPlexAlbums().ToArray();
var modifiedModel = new List<RequestedModel>(); var modifiedModel = new List<RequestedModel>();
foreach (var r in requestedModels) foreach (var r in requestedModels)
{ {
Log.Trace("We are going to see if Plex has the following title: {0}", r.Title); Log.Trace("We are going to see if Plex has the following title: {0}", r.Title);
PlexSearch results;
try
{
results = PlexApi.SearchContent(authSettings.PlexAuthToken, r.Title, plexSettings.FullUri);
}
catch (Exception e)
{
Log.Error("We failed to search Plex for the following request:");
Log.Error(r.DumpJson());
Log.Error(e);
break; // Let's finish processing and not crash the process, there is a reason why we cannot connect.
}
if (results == null) if (libraries == null)
{ {
Log.Trace("Could not find any matching result for this title."); libraries = new List<PlexSearch>() { PlexApi.SearchContent(authSettings.PlexAuthToken, r.Title, plexSettings.FullUri) };
continue; if (libraries == null)
{
Log.Trace("Could not find any matching result for this title.");
continue;
}
} }
Log.Trace("Search results from Plex for the following request: {0}", r.Title); Log.Trace("Search results from Plex for the following request: {0}", r.Title);
Log.Trace(results.DumpJson()); //Log.Trace(results.DumpJson());
bool matchResult;
var releaseDate = r.ReleaseDate == DateTime.MinValue ? string.Empty : r.ReleaseDate.ToString("yyyy"); var releaseDate = r.ReleaseDate == DateTime.MinValue ? string.Empty : r.ReleaseDate.ToString("yyyy");
bool matchResult;
switch (r.Type) switch (r.Type)
{ {
case RequestType.Movie: case RequestType.Movie:
matchResult = MovieTvSearch(results, r.Title, releaseDate); matchResult = IsMovieAvailable(movies, r.Title, releaseDate);
break; break;
case RequestType.TvShow: case RequestType.TvShow:
matchResult = MovieTvSearch(results, r.Title, releaseDate); matchResult = IsTvShowAvailable(shows, r.Title, releaseDate);
break; break;
case RequestType.Album: case RequestType.Album:
matchResult = AlbumSearch(results, r.Title, r.ArtistName); matchResult = IsAlbumAvailable(albums, r.Title, r.ReleaseDate.Year.ToString(), r.ArtistName);
break; break;
default: default:
throw new ArgumentOutOfRangeException(); throw new ArgumentOutOfRangeException();
} }
if (matchResult) if (matchResult)
{ {
r.Available = true; r.Available = true;
@ -138,118 +139,143 @@ namespace PlexRequests.Services
} }
} }
/// <summary> public List<PlexMovie> GetPlexMovies()
/// Determines whether the specified title is available.
/// </summary>
/// <param name="title">The title.</param>
/// <param name="year">The year.</param>
/// <param name="artist">The artist.</param>
/// <param name="type">The type.</param>
/// <returns></returns>
/// <exception cref="ApplicationSettingsException">The settings are not configured for Plex or Authentication</exception>
/// <exception cref="System.ArgumentOutOfRangeException">null</exception>
public bool IsAvailable(string title, string year, string artist, PlexType type)
{ {
Log.Trace("Checking if the following {0} {1} is available in Plex", title, year); var movies = new List<PlexMovie>();
var plexSettings = Plex.GetSettings(); var libs = Cache.Get<List<PlexSearch>>(CacheKeys.PlexLibaries);
var authSettings = Auth.GetSettings(); if (libs != null)
if (!ValidateSettings(plexSettings, authSettings))
{ {
Log.Warn("The settings are not configured"); var movieLibs = libs.Where(x =>
throw new ApplicationSettingsException("The settings are not configured for Plex or Authentication"); x.Video.Any(y =>
} y.Type.Equals(PlexMediaType.Movie.ToString(), StringComparison.CurrentCultureIgnoreCase)
var results = PlexApi.SearchContent(authSettings.PlexAuthToken, title, plexSettings.FullUri); )
).ToArray();
switch (type) foreach (var lib in movieLibs)
{ {
case PlexType.Movie: movies.AddRange(lib.Video.Select(x => new PlexMovie() // movies are in the Video list
return MovieTvSearch(results, title, year); {
case PlexType.TvShow: Title = x.Title,
return MovieTvSearch(results, title, year); ReleaseYear = x.Year
case PlexType.Music: }));
return AlbumSearch(results, title, artist); }
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
} }
return movies;
}
public bool IsMovieAvailable(PlexMovie[] plexMovies, string title, string year)
{
return plexMovies.Any(x => x.Title.Equals(title, StringComparison.CurrentCultureIgnoreCase) && x.ReleaseYear.Equals(year, StringComparison.CurrentCultureIgnoreCase));
} }
/// <summary> public List<PlexTvShow> GetPlexTvShows()
/// Searches the movies and TV shows on Plex.
/// </summary>
/// <param name="results">The results.</param>
/// <param name="title">The title.</param>
/// <param name="year">The year.</param>
/// <returns></returns>
private bool MovieTvSearch(PlexSearch results, string title, string year)
{ {
try var shows = new List<PlexTvShow>();
var libs = Cache.Get<List<PlexSearch>>(CacheKeys.PlexLibaries);
if (libs != null)
{ {
var tvLibs = libs.Where(x =>
x.Directory.Any(y =>
y.Type.Equals(PlexMediaType.Show.ToString(), StringComparison.CurrentCultureIgnoreCase)
)
).ToArray();
if (!string.IsNullOrEmpty(year)) foreach (var lib in tvLibs)
{ {
var result = results.Video?.FirstOrDefault(x => x.Title.Equals(title, StringComparison.InvariantCultureIgnoreCase) && x.Year == year); shows.AddRange(lib.Directory.Select(x => new PlexTvShow() // shows are in the directory list
var directoryResult = false;
if (results.Directory != null)
{ {
if (results.Directory.Any(d => d.Title.Equals(title, StringComparison.CurrentCultureIgnoreCase) && d.Year == year)) Title = x.Title,
{ ReleaseYear = x.Year
directoryResult = true; }));
}
}
return result?.Title != null || directoryResult;
} }
else }
return shows;
}
public bool IsTvShowAvailable(PlexTvShow[] plexShows, string title, string year)
{
return plexShows.Any(x => x.Title.Equals(title, StringComparison.CurrentCultureIgnoreCase) && x.ReleaseYear.Equals(year, StringComparison.CurrentCultureIgnoreCase));
}
public List<PlexAlbum> GetPlexAlbums()
{
var albums = new List<PlexAlbum>();
var libs = Cache.Get<List<PlexSearch>>(CacheKeys.PlexLibaries);
if (libs != null)
{
var albumLibs = libs.Where(x =>
x.Directory.Any(y =>
y.Type.Equals(PlexMediaType.Show.ToString(), StringComparison.CurrentCultureIgnoreCase)
)
).ToArray();
foreach (var lib in albumLibs)
{ {
var result = results.Video?.FirstOrDefault(x => x.Title.Equals(title, StringComparison.InvariantCultureIgnoreCase)); albums.AddRange(lib.Directory.Select(x => new PlexAlbum()
var directoryResult = false;
if (results.Directory != null)
{ {
if (results.Directory.Any(d => d.Title.Equals(title, StringComparison.CurrentCultureIgnoreCase))) Title = x.Title,
{ ReleaseYear = x.Year,
directoryResult = true; Artist = x.ParentTitle
} }));
}
return result?.Title != null || directoryResult;
} }
} }
catch (Exception e) return albums;
}
public bool IsAlbumAvailable(PlexAlbum[] plexAlbums, string title, string year, string artist)
{
return plexAlbums.Any(x =>
x.Title.Contains(title) &&
//x.ReleaseYear.Equals(year, StringComparison.CurrentCultureIgnoreCase) &&
x.Artist.Equals(artist, StringComparison.CurrentCultureIgnoreCase));
}
private List<PlexSearch> CachedLibraries(AuthenticationSettings authSettings, PlexSettings plexSettings, bool setCache)
{
Log.Trace("Obtaining library sections from Plex for the following request");
List<PlexSearch> results = new List<PlexSearch>();
if (!ValidateSettings(plexSettings, authSettings))
{ {
Log.Error("Could not finish the Movie/TV check in Plex because of an exception:"); Log.Warn("The settings are not configured");
Log.Error(e); return results; // don't error out here, just let it go!
return false; }
if (setCache)
{
results = GetLibraries(authSettings, plexSettings);
Cache.Set(CacheKeys.PlexLibaries, results, 10);
}
else
{
results = Cache.GetOrSet(CacheKeys.PlexLibaries, () => {
return GetLibraries(authSettings, plexSettings);
}, 10);
} }
return results;
} }
/// <summary> private List<PlexSearch> GetLibraries(AuthenticationSettings authSettings, PlexSettings plexSettings)
/// Searches the music on Plex.
/// </summary>
/// <param name="results">The results.</param>
/// <param name="title">The title.</param>
/// <param name="artist">The artist.</param>
/// <returns></returns>
private bool AlbumSearch(PlexSearch results, string title, string artist)
{ {
try var sections = PlexApi.GetLibrarySections(authSettings.PlexAuthToken, plexSettings.FullUri);
List<PlexSearch> libs = new List<PlexSearch>();
if (sections != null)
{ {
foreach (var r in results.Directory) foreach (var dir in sections.Directories)
{ {
var titleMatch = r.Title.Contains(title); Log.Trace("Obtaining results from Plex for the following library section: {0}", dir.Title);
var artistMatch = r.ParentTitle.Equals(artist, StringComparison.CurrentCultureIgnoreCase); var lib = PlexApi.GetLibrary(authSettings.PlexAuthToken, plexSettings.FullUri, dir.Key);
if (titleMatch && artistMatch) if (lib != null)
{ {
return true; libs.Add(lib);
} }
} }
} }
catch (Exception e)
{ return libs;
Log.Error("Could not finish the Album check in Plex because of an exception:"); }
Log.Error(e);
}
return false;
}
private bool ValidateSettings(PlexSettings plex, AuthenticationSettings auth) private bool ValidateSettings(PlexSettings plex, AuthenticationSettings auth)
{ {

3
PlexRequests.Services/PlexRequests.Services.csproj
Unescape View File

@ -84,6 +84,9 @@
<Reference Include="System.Xml" /> <Reference Include="System.Xml" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<Compile Include="Models\PlexAlbum.cs" />
<Compile Include="Models\PlexMovie.cs" />
<Compile Include="Models\PlexTvShow.cs" />
<Compile Include="SickRageCacher.cs" /> <Compile Include="SickRageCacher.cs" />
<Compile Include="Interfaces\ISickRageCacher.cs" /> <Compile Include="Interfaces\ISickRageCacher.cs" />
<Compile Include="SonarrCacher.cs" /> <Compile Include="SonarrCacher.cs" />

47
PlexRequests.UI/Modules/SearchModule.cs
Unescape View File

@ -62,8 +62,12 @@ namespace PlexRequests.UI.Modules
IRequestService request, ISonarrApi sonarrApi, ISettingsService<SonarrSettings> sonarrSettings, IRequestService request, ISonarrApi sonarrApi, ISettingsService<SonarrSettings> sonarrSettings,
ISettingsService<SickRageSettings> sickRageService, ICouchPotatoApi cpApi, ISickRageApi srApi, ISettingsService<SickRageSettings> sickRageService, ICouchPotatoApi cpApi, ISickRageApi srApi,
INotificationService notify, IMusicBrainzApi mbApi, IHeadphonesApi hpApi, ISettingsService<HeadphonesSettings> hpService, INotificationService notify, IMusicBrainzApi mbApi, IHeadphonesApi hpApi, ISettingsService<HeadphonesSettings> hpService,
ICouchPotatoCacher cpCacher, ISonarrCacher sonarrCacher, ISickRageCacher sickRageCacher) : base("search") ICouchPotatoCacher cpCacher, ISonarrCacher sonarrCacher, ISickRageCacher sickRageCacher, IPlexApi plexApi,
ISettingsService<PlexSettings> plexService, ISettingsService<AuthenticationSettings> auth) : base("search")
{ {
Auth = auth;
PlexService = plexService;
PlexApi = plexApi;
CpService = cpSettings; CpService = cpSettings;
PrService = prSettings; PrService = prSettings;
MovieApi = new TheMovieDbApi(); MovieApi = new TheMovieDbApi();
@ -99,6 +103,7 @@ namespace PlexRequests.UI.Modules
Post["request/tv"] = parameters => RequestTvShow((int)Request.Form.tvId, (string)Request.Form.seasons); Post["request/tv"] = parameters => RequestTvShow((int)Request.Form.tvId, (string)Request.Form.seasons);
Post["request/album"] = parameters => RequestAlbum((string)Request.Form.albumId); Post["request/album"] = parameters => RequestAlbum((string)Request.Form.albumId);
} }
private IPlexApi PlexApi { get; }
private TheMovieDbApi MovieApi { get; } private TheMovieDbApi MovieApi { get; }
private INotificationService NotificationService { get; } private INotificationService NotificationService { get; }
private ICouchPotatoApi CouchPotatoApi { get; } private ICouchPotatoApi CouchPotatoApi { get; }
@ -107,6 +112,8 @@ namespace PlexRequests.UI.Modules
private ISickRageApi SickrageApi { get; } private ISickRageApi SickrageApi { get; }
private IRequestService RequestService { get; } private IRequestService RequestService { get; }
private ICacheProvider Cache { get; } private ICacheProvider Cache { get; }
private ISettingsService<AuthenticationSettings> Auth { get; }
private ISettingsService<PlexSettings> PlexService { get; }
private ISettingsService<CouchPotatoSettings> CpService { get; } private ISettingsService<CouchPotatoSettings> CpService { get; }
private ISettingsService<PlexRequestSettings> PrService { get; } private ISettingsService<PlexRequestSettings> PrService { get; }
private ISettingsService<SonarrSettings> SonarrService { get; } private ISettingsService<SonarrSettings> SonarrService { get; }
@ -207,6 +214,7 @@ namespace PlexRequests.UI.Modules
Task.WaitAll(taskList.ToArray()); Task.WaitAll(taskList.ToArray());
int[] cpCached = CpCacher.QueuedIds(); int[] cpCached = CpCacher.QueuedIds();
var plexMovies = Checker.GetPlexMovies();
List<SearchMovieViewModel> viewMovies = new List<SearchMovieViewModel>(); List<SearchMovieViewModel> viewMovies = new List<SearchMovieViewModel>();
foreach (MovieResult movie in apiMovies) foreach (MovieResult movie in apiMovies)
@ -229,7 +237,11 @@ namespace PlexRequests.UI.Modules
VoteCount = movie.VoteCount VoteCount = movie.VoteCount
}; };
if (dbMovies.ContainsKey(movie.Id)) // compare to the requests db if (Checker.IsMovieAvailable(plexMovies.ToArray(), movie.Title, movie.ReleaseDate?.Year.ToString()))
{
viewMovie.Available = true;
}
else if (dbMovies.ContainsKey(movie.Id)) // compare to the requests db
{ {
var dbm = dbMovies[movie.Id]; var dbm = dbMovies[movie.Id];
@ -284,6 +296,7 @@ namespace PlexRequests.UI.Modules
int[] sonarrCached = SonarrCacher.QueuedIds(); int[] sonarrCached = SonarrCacher.QueuedIds();
int[] sickRageCache = SickRageCacher.QueuedIds(); // consider just merging sonarr/sickrage arrays int[] sickRageCache = SickRageCacher.QueuedIds(); // consider just merging sonarr/sickrage arrays
var plexTvShows = Checker.GetPlexTvShows();
var viewTv = new List<SearchTvShowViewModel>(); var viewTv = new List<SearchTvShowViewModel>();
foreach (var t in apiTv) foreach (var t in apiTv)
@ -306,7 +319,11 @@ namespace PlexRequests.UI.Modules
Status = t.show.status Status = t.show.status
}; };
if (t.show.externals.thetvdb != null) if (Checker.IsTvShowAvailable(plexTvShows.ToArray(), t.show.name, t.show.premiered?.Substring(0, 4)))
{
viewT.Available = true;
}
else if (t.show.externals.thetvdb != null)
{ {
int tvdbid = (int)t.show.externals.thetvdb; int tvdbid = (int)t.show.externals.thetvdb;
@ -358,6 +375,8 @@ namespace PlexRequests.UI.Modules
Task.WaitAll(taskList.ToArray()); Task.WaitAll(taskList.ToArray());
var plexAlbums = Checker.GetPlexAlbums();
var viewAlbum = new List<SearchMusicViewModel>(); var viewAlbum = new List<SearchMusicViewModel>();
foreach (var a in apiAlbums) foreach (var a in apiAlbums)
{ {
@ -373,6 +392,13 @@ namespace PlexRequests.UI.Modules
Country = a.country Country = a.country
}; };
DateTime release;
DateTimeHelper.CustomParse(a.ReleaseEvents?.FirstOrDefault()?.date, out release);
var artist = a.ArtistCredit?.FirstOrDefault()?.artist;
if (Checker.IsAlbumAvailable(plexAlbums.ToArray(), a.title, release.ToString("yyyy"), artist.name))
{
viewA.Available = true;
}
if (!string.IsNullOrEmpty(a.id) && dbAlbum.ContainsKey(a.id)) if (!string.IsNullOrEmpty(a.id) && dbAlbum.ContainsKey(a.id))
{ {
var dba = dbAlbum[a.id]; var dba = dbAlbum[a.id];
@ -417,7 +443,8 @@ namespace PlexRequests.UI.Modules
try try
{ {
if (CheckIfTitleExistsInPlex(movieInfo.Title, movieInfo.ReleaseDate?.Year.ToString(), null, PlexType.Movie)) var movies = Checker.GetPlexMovies();
if (Checker.IsMovieAvailable(movies.ToArray(), movieInfo.Title, movieInfo.ReleaseDate?.Year.ToString()))
{ {
return Response.AsJson(new JsonResponseModel { Result = false, Message = $"{fullMovieName} is already in Plex!" }); return Response.AsJson(new JsonResponseModel { Result = false, Message = $"{fullMovieName} is already in Plex!" });
} }
@ -553,7 +580,8 @@ namespace PlexRequests.UI.Modules
try try
{ {
if (CheckIfTitleExistsInPlex(showInfo.name, showInfo.premiered?.Substring(0, 4), null, PlexType.TvShow)) // Take only the year Format = 2014-01-01 var shows = Checker.GetPlexTvShows();
if (Checker.IsTvShowAvailable(shows.ToArray(), showInfo.name, showInfo.premiered?.Substring(0, 4)))
{ {
return Response.AsJson(new JsonResponseModel { Result = false, Message = $"{fullShowName} is already in Plex!" }); return Response.AsJson(new JsonResponseModel { Result = false, Message = $"{fullShowName} is already in Plex!" });
} }
@ -652,12 +680,6 @@ namespace PlexRequests.UI.Modules
return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullShowName} was successfully added!" }); return Response.AsJson(new JsonResponseModel { Result = true, Message = $"{fullShowName} was successfully added!" });
} }
private bool CheckIfTitleExistsInPlex(string title, string year, string artist, PlexType type)
{
var result = Checker.IsAvailable(title, year, artist, type);
return result;
}
private Response RequestAlbum(string releaseId) private Response RequestAlbum(string releaseId)
{ {
var settings = PrService.GetSettings(); var settings = PrService.GetSettings();
@ -689,7 +711,8 @@ namespace PlexRequests.UI.Modules
return Response.AsJson(new JsonResponseModel { Result = false, Message = "We could not find the artist on MusicBrainz. Please try again later or contact your admin" }); return Response.AsJson(new JsonResponseModel { Result = false, Message = "We could not find the artist on MusicBrainz. Please try again later or contact your admin" });
} }
var alreadyInPlex = CheckIfTitleExistsInPlex(albumInfo.title, release.ToString("yyyy"), artist.name, PlexType.Music); var albums = Checker.GetPlexAlbums();
var alreadyInPlex = Checker.IsAlbumAvailable(albums.ToArray(), albumInfo.title, release.ToString("yyyy"), artist.name);
if (alreadyInPlex) if (alreadyInPlex)
{ {

Write Preview
Loading…
Cancel
Save