public async Task SyncsMovieWithGuidFromInitalMetadata()
{
var content = new Mediacontainer
{
Metadata = new[]
{
new Metadata
{
title = "test1",
year = 2021,
type = "movie",
Guid = new List <PlexGuids>
{
new PlexGuids
{
Id = "imdb://tt0322259"
}
},
ratingKey = "1"
},
}
};
var contentToAdd = new HashSet <PlexServerContent>();
var contentProcessed = new Dictionary <int, string>();
await _subject.MovieLoop(new PlexServers(), content, contentToAdd, contentProcessed);
var first = contentToAdd.First();
Assert.That(first.ImdbId, Is.EqualTo("tt0322259"));
_mocker.Verify <IPlexApi>(x => x.GetMetadata(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
public async Task DoesNotSyncExistingMovie()
{
var content = new Mediacontainer
{
Metadata = new[]
{
new Metadata
{
title = "test1",
year = 2021,
type = "movie"
},
}
};
var contentToAdd = new HashSet <PlexServerContent>();
var contentProcessed = new Dictionary <int, string>();
_mocker.Setup <IPlexContentRepository>(x =>
x.GetFirstContentByCustom(It.IsAny <Expression <Func <PlexServerContent, bool> > >()))
.Returns(Task.FromResult(new PlexServerContent()));
await _subject.MovieLoop(new PlexServers(), content, contentToAdd, contentProcessed);
Assert.That(contentToAdd, Is.Empty);
}
public async Task SyncsMovieWithGuidFromCallToApi()
{
var content = new Mediacontainer
{
Metadata = new[]
{
new Metadata
{
ratingKey = "11",
title = "test1",
year = 2021,
type = "movie",
},
}
};
var contentToAdd = new HashSet <PlexServerContent>();
var contentProcessed = new Dictionary <int, string>();
_mocker.Setup <IPlexApi>(x => x.GetMetadata(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(new PlexMetadata
{
MediaContainer = new Mediacontainer
{
Metadata = new[]
{
new Metadata
{
ratingKey = "11",
title = "test1",
year = 2021,
type = "movie",
Guid = new List <PlexGuids>
{
new PlexGuids
{
Id = "imdb://tt0322259"
}
},
}
}
}
}));
await _subject.MovieLoop(new PlexServers { Ip = "http://test.com/", Port = 80 }, content, contentToAdd, contentProcessed);
var first = contentToAdd.First();
Assert.That(first.ImdbId, Is.EqualTo("tt0322259"));
_mocker.Verify <IPlexApi>(x => x.GetMetadata(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public async Task DoesNotUpdatesExistingMovieWhen_WeFindSameQuality()
{
var content = new Mediacontainer
{
Metadata = new[]
{
new Metadata
{
ratingKey = "11",
title = "test1",
year = 2021,
type = "movie",
Media = new Medium[1]
{
new Medium
{
videoResolution = "1080"
}
}
},
}
};
var contentToAdd = new HashSet <PlexServerContent>();
var contentProcessed = new Dictionary <int, string>();
_mocker.Setup <IPlexContentRepository>(x =>
x.GetFirstContentByCustom(It.IsAny <Expression <Func <PlexServerContent, bool> > >()))
.Returns(Task.FromResult(new PlexServerContent
{
Quality = "1080"
}));
await _subject.MovieLoop(new PlexServers(), content, contentToAdd, contentProcessed);
Assert.That(contentToAdd, Is.Empty);
_mocker.Verify <IPlexContentRepository>(x => x.Update(It.IsAny <PlexServerContent>()), Times.Never);
}
public async Task MovieLoop(PlexServers servers, Mediacontainer content, HashSet <PlexServerContent> contentToAdd,
Dictionary <int, int> contentProcessed)
{
Logger.LogDebug("Processing Movies");
foreach (var movie in content?.Metadata ?? new Metadata[] { })
{
// Let's check if we have this movie
try
{
var existing = await Repo.GetFirstContentByCustom(x => x.Title == movie.title &&
x.ReleaseYear == movie.year.ToString() &&
x.Type == PlexMediaTypeEntity.Movie);
// The rating key keeps changing
//var existing = await Repo.GetByKey(movie.ratingKey);
if (existing != null)
{
Logger.LogDebug("We already have movie {0}", movie.title);
continue;
}
var hasSameKey = await Repo.GetByKey(movie.ratingKey);
if (hasSameKey != null)
{
await Repo.Delete(hasSameKey);
}
Logger.LogDebug("Adding movie {0}", movie.title);
var guids = new List <string>();
if (!movie.Guid.Any())
{
var metaData = await PlexApi.GetMetadata(servers.PlexAuthToken, servers.FullUri,
movie.ratingKey);
var meta = metaData.MediaContainer.Metadata.FirstOrDefault();
guids.Add(meta.guid);
if (meta.Guid != null)
{
foreach (var g in meta.Guid)
{
guids.Add(g.Id);
}
}
}
else
{
// Currently a Plex Pass feature only
foreach (var g in movie.Guid)
{
guids.Add(g.Id);
}
}
var providerIds = PlexHelper.GetProviderIdsFromMetadata(guids.ToArray());
var item = new PlexServerContent
{
AddedAt = DateTime.Now,
Key = movie.ratingKey,
ReleaseYear = movie.year.ToString(),
Type = PlexMediaTypeEntity.Movie,
Title = movie.title,
Url = PlexHelper.GetPlexMediaUrl(servers.MachineIdentifier, movie.ratingKey),
Seasons = new List <PlexSeasonsContent>(),
Quality = movie.Media?.FirstOrDefault()?.videoResolution ?? string.Empty
};
if (providerIds.ImdbId.HasValue())
{
item.ImdbId = providerIds.ImdbId;
}
if (providerIds.TheMovieDb.HasValue())
{
item.TheMovieDbId = providerIds.TheMovieDb;
}
if (providerIds.TheTvDb.HasValue())
{
item.TvDbId = providerIds.TheTvDb;
}
contentToAdd.Add(item);
}
catch (Exception e)
{
Logger.LogError(LoggingEvents.PlexContentCacher, e, "Exception when adding new Movie {0}",
movie.title);
}
if (contentToAdd.Count > 500)
{
await Repo.AddRange(contentToAdd);
foreach (var c in contentToAdd)
{
contentProcessed.Add(c.Id, c.Key);
}
contentToAdd.Clear();
}
}
}
public async Task MovieLoop(PlexServers servers, Mediacontainer content, HashSet <PlexServerContent> contentToAdd,
Dictionary <int, string> contentProcessed)
{
Logger.LogDebug("Processing Movies");
foreach (var movie in content?.Metadata ?? Array.Empty <Metadata>())
{
// Let's check if we have this movie
try
{
var existing = await Repo.GetFirstContentByCustom(x => x.Title == movie.title &&
x.ReleaseYear == movie.year.ToString() &&
x.Type == MediaType.Movie);
if (existing != null)
{
// We need to see if this is a different quality,
// We want to know if this is a 4k content for example
var foundQualities = movie.Media?.Select(x => x.videoResolution);
var qualitySaved = false;
foreach (var quality in foundQualities)
{
if (qualitySaved)
{
break;
}
if (quality.Equals(existing.Quality))
{
// We got it
continue;
}
// We don't have this quality
if (quality.Equals("4k", StringComparison.InvariantCultureIgnoreCase))
{
Logger.LogDebug($"We already have movie {movie.title}, But found a 4K version!");
existing.Has4K = true;
await Repo.Update(existing);
}
else
{
qualitySaved = true;
existing.Quality = quality;
await Repo.Update(existing);
}
}
Logger.LogDebug($"We already have movie {movie.title}");
continue;
}
//var hasSameKey = await Repo.GetByKey(movie.ratingKey);
//if (hasSameKey != null)
//{
// await Repo.Delete(hasSameKey);
//}
Logger.LogDebug("Adding movie {0}", movie.title);
var guids = new List <string>();
if (!movie.Guid.Any())
{
var metaData = await PlexApi.GetMetadata(servers.PlexAuthToken, servers.FullUri,
movie.ratingKey);
var meta = metaData.MediaContainer.Metadata.FirstOrDefault();
guids.Add(meta.guid);
if (meta.Guid != null)
{
foreach (var g in meta.Guid)
{
guids.Add(g.Id);
}
}
}
else
{
// Currently a Plex Pass feature only
foreach (var g in movie.Guid)
{
guids.Add(g.Id);
}
}
if (!guids.Any())
{
Logger.LogWarning($"Movie {movie.title} has no relevant metadata. Skipping.");
continue;
}
var providerIds = PlexHelper.GetProviderIdsFromMetadata(guids.ToArray());
if (!providerIds.Any())
{
Logger.LogWarning($"Movie {movie.title} has no External Ids in Plex (ImdbId, TheMovieDbId). Skipping.");
continue;
}
var qualities = movie?.Media?.Select(x => x?.videoResolution ?? string.Empty) ?? Enumerable.Empty <string>();
var is4k = qualities != null && qualities.Any(x => x.Equals("4k", StringComparison.InvariantCultureIgnoreCase));
var selectedQuality = is4k ? null : qualities?.OrderBy(x => x)?.FirstOrDefault() ?? string.Empty;
var item = new PlexServerContent
{
AddedAt = DateTime.Now,
Key = movie.ratingKey,
ReleaseYear = movie.year.ToString(),
Type = MediaType.Movie,
Title = movie.title,
Url = PlexHelper.GetPlexMediaUrl(servers.MachineIdentifier, movie.ratingKey, servers.ServerHostname),
Seasons = new List <PlexSeasonsContent>(),
Quality = selectedQuality,
Has4K = is4k,
};
if (providerIds.ImdbId.HasValue())
{
item.ImdbId = providerIds.ImdbId;
}
if (providerIds.TheMovieDb.HasValue())
{
item.TheMovieDbId = providerIds.TheMovieDb;
}
if (providerIds.TheTvDb.HasValue())
{
item.TvDbId = providerIds.TheTvDb;
}
contentToAdd.Add(item);
}
catch (Exception e)
{
Logger.LogError(LoggingEvents.PlexContentCacher, e, "Exception when adding new Movie {0}",
movie.title);
}
if (contentToAdd.Count > 500)
{
await Repo.AddRange(contentToAdd);
foreach (var c in contentToAdd)
{
contentProcessed.Add(c.Id, c.Key);
}
contentToAdd.Clear();
}
}
}
