public int?GetMetadataId(int sectionId, int tvdbId, string language, PlexServerSettings settings)
{
var guid = $"com.plexapp.agents.thetvdb://{tvdbId}?lang={language}";
var resource = $"library/sections/{sectionId}/all?guid={System.Web.HttpUtility.UrlEncode(guid)}";
var request = BuildRequest(resource, HttpMethod.GET, settings);
var response = ProcessRequest(request);
CheckForError(response);
List <PlexSectionItem> items;
if (response.Contains("_children"))
{
items = Json.Deserialize <PlexSectionResponseLegacy>(response)
.Items;
}
else
{
items = Json.Deserialize <PlexResponse <PlexSectionResponse> >(response)
.MediaContainer
.Items;
}
if (items == null || items.Empty())
{
return(null);
}
return(items.First().Id);
}
public List <PlexSection> GetTvSections(PlexServerSettings settings)
{
var request = BuildRequest("library/sections", HttpMethod.GET, settings);
var response = ProcessRequest(request);
CheckForError(response);
if (response.Contains("_children"))
{
return(Json.Deserialize <PlexMediaContainerLegacy>(response)
.Sections
.Where(d => d.Type == "show")
.Select(s => new PlexSection
{
Id = s.Id,
Language = s.Language,
Locations = s.Locations,
Type = s.Type
})
.ToList());
}
return(Json.Deserialize <PlexResponse <PlexSectionsContainer> >(response)
.MediaContainer
.Sections
.Where(d => d.Type == "show")
.ToList());
}
public void UpdateLibrary(Artist artist, PlexServerSettings settings)
{
try
{
_logger.Debug("Sending Update Request to Plex Server");
var version = _versionCache.Get(settings.Host, () => GetVersion(settings), TimeSpan.FromHours(2));
ValidateVersion(version);
var sections = GetSections(settings);
var partialUpdates = _partialUpdateCache.Get(settings.Host, () => PartialUpdatesAllowed(settings, version), TimeSpan.FromHours(2));
if (partialUpdates)
{
UpdatePartialSection(artist, sections, settings);
}
else
{
sections.ForEach(s => UpdateSection(s.Id, settings));
}
}
catch (Exception ex)
{
_logger.Warn(ex, "Failed to Update Plex host: " + settings.Host);
throw;
}
}
public ValidationFailure Test(PlexServerSettings settings)
{
try
{
_versionCache.Remove(settings.Host);
_partialUpdateCache.Remove(settings.Host);
var sections = GetSections(settings);
if (sections.Empty())
{
return(new ValidationFailure("Host", "At least one TV library is required"));
}
}
catch (PlexAuthenticationException ex)
{
_logger.Error(ex, "Unable to connect to Plex Server");
return(new ValidationFailure("AuthToken", "Invalid authentication token"));
}
catch (Exception ex)
{
_logger.Error(ex, "Unable to connect to Plex Server");
return(new ValidationFailure("Host", "Unable to connect to Plex Server"));
}
return(null);
}
public void Update(int sectionId, PlexServerSettings settings)
{
var resource = $"library/sections/{sectionId}/refresh";
var request = BuildRequest(resource, HttpMethod.GET, settings);
var response = ProcessRequest(request);
CheckForError(response);
}
public void UpdateSeries(int metadataId, PlexServerSettings settings)
{
var resource = $"library/metadata/{metadataId}/refresh";
var request = BuildRequest(resource, HttpMethod.PUT, settings);
var response = ProcessRequest(request);
CheckForError(response);
}
private Version GetVersion(PlexServerSettings settings)
{
_logger.Debug("Getting version from Plex host: {0}", settings.Host);
var rawVersion = _plexServerProxy.Version(settings);
var version = new Version(Regex.Match(rawVersion, @"^(\d+[.-]){4}").Value.Trim('.', '-'));
return(version);
}
public void UpdateLibrary(IEnumerable <Series> multipleSeries, PlexServerSettings settings)
{
try
{
_logger.Debug("Sending Update Request to Plex Server");
var watch = Stopwatch.StartNew();
var version = _versionCache.Get(settings.Host, () => GetVersion(settings), TimeSpan.FromHours(2));
ValidateVersion(version);
var sections = GetSections(settings);
var partialUpdates = _partialUpdateCache.Get(settings.Host, () => PartialUpdatesAllowed(settings, version), TimeSpan.FromHours(2));
if (partialUpdates)
{
var partiallyUpdated = true;
foreach (var series in multipleSeries)
{
partiallyUpdated &= UpdatePartialSection(series, sections, settings);
if (!partiallyUpdated)
{
break;
}
}
// Only update complete sections if all partial updates failed
if (!partiallyUpdated)
{
_logger.Debug("Unable to update partial section, updating all TV sections");
sections.ForEach(s => UpdateSection(s.Id, settings));
}
}
else
{
sections.ForEach(s => UpdateSection(s.Id, settings));
}
_logger.Debug("Finished sending Update Request to Plex Server (took {0} ms)", watch.ElapsedMilliseconds);
}
catch (Exception ex)
{
_logger.Warn(ex, "Failed to Update Plex host: " + settings.Host);
throw;
}
}
public List <PlexPreference> Preferences(PlexServerSettings settings)
{
var request = BuildRequest(":/prefs", HttpMethod.GET, settings);
var response = ProcessRequest(request);
CheckForError(response);
if (response.Contains("_children"))
{
return(Json.Deserialize <PlexPreferencesLegacy>(response)
.Preferences);
}
return(Json.Deserialize <PlexResponse <PlexPreferences> >(response)
.MediaContainer
.Preferences);
}
public string Version(PlexServerSettings settings)
{
var request = BuildRequest("identity", HttpMethod.GET, settings);
var response = ProcessRequest(request);
CheckForError(response);
if (response.Contains("_children"))
{
return(Json.Deserialize <PlexIdentity>(response)
.Version);
}
return(Json.Deserialize <PlexResponse <PlexIdentity> >(response)
.MediaContainer
.Version);
}
private bool UpdatePartialSection(Movie movie, List <PlexSection> sections, PlexServerSettings settings)
{
var partiallyUpdated = false;
foreach (var section in sections)
{
var metadataId = GetMetadataId(section.Id, movie, section.Language, settings);
if (metadataId.HasValue)
{
_logger.Debug("Updating Plex host: {0}, Section: {1}, Movie: {2}", settings.Host, section.Id, movie);
_plexServerProxy.UpdateMovie(metadataId.Value, settings);
partiallyUpdated = true;
}
}
return(partiallyUpdated);
}
private HttpRequestBuilder BuildRequest(string resource, HttpMethod method, PlexServerSettings settings)
{
var scheme = settings.UseSsl ? "https" : "http";
var requestBuilder = new HttpRequestBuilder($"{scheme}://{settings.Host}:{settings.Port}")
.Accept(HttpAccept.Json)
.AddQueryParam("X-Plex-Client-Identifier", _configService.PlexClientIdentifier)
.AddQueryParam("X-Plex-Product", BuildInfo.AppName)
.AddQueryParam("X-Plex-Platform", "Windows")
.AddQueryParam("X-Plex-Platform-Version", "7")
.AddQueryParam("X-Plex-Device-Name", BuildInfo.AppName)
.AddQueryParam("X-Plex-Version", BuildInfo.Version.ToString());
if (settings.AuthToken.IsNotNullOrWhiteSpace())
{
requestBuilder.AddQueryParam("X-Plex-Token", settings.AuthToken);
}
requestBuilder.ResourceUrl = resource;
requestBuilder.Method = method;
return(requestBuilder);
}
private bool PartialUpdatesAllowed(PlexServerSettings settings, Version version)
{
try
{
if (version >= new Version(0, 9, 12, 0))
{
var preferences = GetPreferences(settings);
var partialScanPreference = preferences.SingleOrDefault(p => p.Id.Equals("FSEventLibraryPartialScanEnabled"));
if (partialScanPreference == null)
{
return(false);
}
return(Convert.ToBoolean(partialScanPreference.Value));
}
}
catch (Exception ex)
{
_logger.Warn(ex, "Unable to check if partial updates are allowed");
}
return(false);
}
private void UpdatePartialSection(Artist artist, List <PlexSection> sections, PlexServerSettings settings)
{
var partiallyUpdated = false;
foreach (var section in sections)
{
var metadataId = GetMetadataId(section.Id, artist, section.Language, settings);
if (metadataId.HasValue)
{
_logger.Debug("Updating Plex host: {0}, Section: {1}, Artist: {2}", settings.Host, section.Id, artist);
_plexServerProxy.UpdateArtist(metadataId.Value, settings);
partiallyUpdated = true;
}
}
// Only update complete sections if all partial updates failed
if (!partiallyUpdated)
{
_logger.Debug("Unable to update partial section, updating all Music sections");
sections.ForEach(s => UpdateSection(s.Id, settings));
}
}
private List <PlexSection> GetSections(PlexServerSettings settings)
{
_logger.Debug("Getting sections from Plex host: {0}", settings.Host);
return(_plexServerProxy.GetTvSections(settings).ToList());
}
private int?GetMetadataId(int sectionId, Artist artist, string language, PlexServerSettings settings)
{
_logger.Debug("Getting metadata from Plex host: {0} for artist: {1}", settings.Host, artist);
return(_plexServerProxy.GetMetadataId(sectionId, artist.Metadata.Value.ForeignArtistId, language, settings));
}
public void UpdateLibrary(Series series, PlexServerSettings settings)
{
UpdateLibrary(new[] { series }, settings);
}
private bool UpdatePartialSection(Series series, List <PlexSection> sections, PlexServerSettings settings)
{
var partiallyUpdated = false;
foreach (var section in sections)
{
var metadataId = GetMetadataId(section.Id, series, section.Language, settings);
if (metadataId.IsNotNullOrWhiteSpace())
{
_logger.Debug("Updating Plex host: {0}, Section: {1}, Series: {2}", settings.Host, section.Id, series);
_plexServerProxy.UpdateSeries(metadataId, settings);
partiallyUpdated = true;
}
}
return(partiallyUpdated);
}
private string GetMetadataId(int sectionId, Series series, string language, PlexServerSettings settings)
{
_logger.Debug("Getting metadata from Plex host: {0} for series: {1}", settings.Host, series);
return(_plexServerProxy.GetMetadataId(sectionId, series.TvdbId, language, settings));
}
private void UpdateSection(int sectionId, PlexServerSettings settings)
{
_logger.Debug("Updating Plex host: {0}, Section: {1}", settings.Host, sectionId);
_plexServerProxy.Update(sectionId, settings);
}
private List <PlexPreference> GetPreferences(PlexServerSettings settings)
{
_logger.Debug("Getting preferences from Plex host: {0}", settings.Host);
return(_plexServerProxy.Preferences(settings));
}
private int?GetMetadataId(int sectionId, Movie movie, string language, PlexServerSettings settings)
{
_logger.Debug("Getting metadata from Plex host: {0} for movie: {1}", settings.Host, movie);
return(_plexServerProxy.GetMetadataId(sectionId, movie.ImdbId, language, settings));
}
public void UpdateLibrary(Movie movie, PlexServerSettings settings)
{
UpdateLibrary(new[] { movie }, settings);
}
public void UpdateLibrary(Artist artist, PlexServerSettings settings)
{
UpdateLibrary(new[] { artist }, settings);
}
