public ActionResult Get(string id)
{
var resultado = new FilmeIMDBJsonResult();
var filme = new Imdb(false);
filme.FilmePorId(id);
if (filme != null)
{
resultado.IDImdb = id;
resultado.Titulo = filme.Nome;
resultado.URLPoster = filme.PosterURL;
resultado.URLImdb = filme.URLFilme;
resultado.AnoLancamento = filme.AnoLancamento;
resultado.Diretor = filme.Diretor;
resultado.Generos = filme.Generos;
resultado.Sinopse = filme.Sinopse;
resultado.Duracao = filme.Duracao;
foreach (var ator in filme.Atores)
{
resultado.Cast += ator.ToString() + "<br />";
}
}
return(this.Jsonp(resultado));
}
public ActionResult GetComplete(string id)
{
var resultado = new FilmeIMDBJsonResult();
var filme = new Imdb(true);
filme.FilmePorId(id);
if (filme != null)
{
resultado.IDImdb = id;
resultado.Titulo = filme.Nome;
resultado.URLPoster = filme.PosterURL;
resultado.URLImdb = filme.URLFilme;
resultado.AnoLancamento = filme.AnoLancamento;
resultado.Diretor = filme.Diretor;
resultado.Generos = filme.Generos;
resultado.Sinopse = filme.Sinopse;
resultado.Duracao = filme.Duracao;
resultado.ListaAtores = new List <AtorIMDBJsonResult>();
foreach (var ator in filme.Atores)
{
resultado.ListaAtores.Add(new AtorIMDBJsonResult()
{
URLImdb = ator.URLImdb, IDImdb = ator.IdImdb, Nome = ator.Nome, Papel = ator.Papel, URLFoto = ator.URLFoto
});
}
}
return(this.Jsonp(resultado));
}
public ImdbMovie GetMovieData(string movieName)
{
string API_KEY = _configuration.GetSection("AppSettings")["ImdbApiKey"];
var imdb = new Imdb(API_KEY);
var movie = imdb.GetMovieAsync(movieName);
return(movie.Result);
}
public UsersController(MovieService movieService, UserService userService, TrackService trackService, IOptions <AppSettings> appSettings)
{
_movieService = movieService;
_userService = userService;
_trackService = trackService;
_appSettings = appSettings.Value;
_imdb = new Imdb(appSettings.Value.ImdbApiKey);
_musicClient = new LastfmClient(appSettings.Value.LastfmApiKey, appSettings.Value.LastfmApiSecret);
}
public Trailer FillTrailerData(Imdb imdb)
{
Trailer trailer = new Trailer();
Youtube youtube = GetYouTube(imdb);
trailer.Id = youtube.Id;
trailer.Thumbnail = youtube.Thumbnail;
trailer.Title = imdb.Title;
trailer.TitleDescription = RetrieveTitleDescriptionForSearch(imdb.TitleDescription);
return(trailer);
}
public bool GetRating(RatingType type, out double rating)
{
rating = 0;
switch (type)
{
case RatingType.Imdb:
if (Imdb.IsDefault())
{
return(false);
}
rating = Imdb * 10;
return(true);
case RatingType.RtFresh:
if (RtFresh.IsDefault())
{
return(false);
}
rating = RtFresh;
return(true);
case RatingType.RtRating:
if (RtRating.IsDefault())
{
return(false);
}
rating = RtRating * 10;
return(true);
case RatingType.MetaCritic:
if (Math.Abs(MetaCritic) < double.Epsilon)
{
return(false);
}
rating = MetaCritic;
return(true);
case RatingType.Ebert:
if (EbertRating.IsDefault())
{
return(false);
}
rating = (Convert.ToDouble(EbertRating) / 4) * 100;
return(true);
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public async Task <string> GetImdbRating(string movieId)
{
try
{
var imdb = new Imdb("8c75101");
var movie = await imdb.GetMovieAsync(movieId);
return(movie.ImdbRating);
}
catch (Exception)
{
throw;
}
}
public ActionResult Search(string term)
{
var resultado = new List <PesquisaFilmesJsonResult>();
var pesquisaFilmes = new Imdb(false);
var filmesResult = pesquisaFilmes.PesquisarFilmes(term).Take(10);
foreach (var filmeResult in filmesResult)
{
resultado.Add(new PesquisaFilmesJsonResult()
{
label = filmeResult.Nome, image = filmeResult.URLImagem, imdb = filmeResult.URLFilme
});
}
return(this.Jsonp(resultado));
}
public async Task <IActionResult> AddImdbAsync([FromBody] AddImdbRequest imdb)
{
try
{
var newImdb = new Imdb()
{
Votes = imdb.Votes, Rating = imdb.Rating, MovieId = imdb.MovieId
};
await _dbContext.Imdbs.InsertOneAsync(newImdb);
return(Ok(newImdb));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
internal static void SyncRating(string directory, int level = 2, bool isDryRun = false, Action <string>?log = null)
{
log ??= TraceLog;
EnumerateDirectories(directory, level)
.ToArray()
.ForEach(movie =>
{
string metadataPath = Directory.GetFiles(movie, XmlMetadataSearchPattern).First();
XDocument metadata = XDocument.Load(metadataPath);
XElement?ratingElement = metadata.Root !.Element("rating");
if (Imdb.TryLoad(movie, out ImdbMetadata? imdbMetadata) && imdbMetadata.AggregateRating?.RatingValue is not null)
{
// IMDB has rating.
string jsonRatingFormatted = imdbMetadata.AggregateRating.RatingValue.Replace(".0", string.Empty);
if (string.Equals(ratingElement?.Value, jsonRatingFormatted))
{
return;
}
log($"{movie} rating {ratingElement?.Value} is set to {jsonRatingFormatted}.");
if (!isDryRun)
{
metadata.Root !.SetElementValue("rating", jsonRatingFormatted);
metadata.Save(metadataPath);
}
}
else
{
// IMDB has no rating.
if (ratingElement is null)
{
return;
}
log($"{movie} rating {ratingElement.Value} is removed.");
if (!isDryRun)
{
ratingElement.Remove();
metadata.Save(metadataPath);
}
}
});
}
public void DelecaoRepositorio()
{
//var repo = new DataRepository<Usuario>();
//var user = repo.Single(u => u.IdUsuario == 1);
//user.Advertido = true;
//repo.SaveChanges();
//MonoTorrent.Common.Torrent torr = MonoTorrent.Common.Torrent.Load("C:\\Users\\Cury\\Desktop\\Torrents To Go\\The Mentalist S05E09 HDTV XviD-SaM.torrent");
var filme = new Imdb(false);
filme.FilmePorUrl("http://www.imdb.com/title/tt0118583/");
//filme.FilmePorId("0350804");
var act = filme.Atores;
//string a = filme.PosterURL;
//WebClient client = new WebClient();
//client.DownloadFile(a, "E:\\imagem.jpg");
}
// Private Methods (2)
private static bool processNewMovieFile(ref long userImdbId, MovieFileInfo fileInfo, ref TryUploadResult res, Exception ex)
{
if (ex.Message.Contains("response contains boolean value where array expected")) // what did you expect from PHP developers?!
{
if (userImdbId == 0)
{
userImdbId = Imdb.GetImdbId(Path.GetFileNameWithoutExtension(fileInfo.MovieFileName));
if (userImdbId == 0)
{
throw new NotSupportedException("It's a new movie file. Please find/fill its IMDB Id first.");
}
LogWindow.AddMessage(LogType.Info, string.Format("ImdbId: {0}", userImdbId));
}
//it's a new movie file and site's db has no info (IDMovieImdb val) about it.
res = new TryUploadResult {
data = null, status = "200 OK", alreadyindb = 0
};
return(true);
}
return(false);
}
public Youtube GetYouTube(Imdb imdb)
{
Youtube youtube = new Youtube();
var youtubeService = new YouTubeService(new BaseClientService.Initializer()
{
ApiKey = "AIzaSyDPdiKDpjnwevDYtAMuMiFI0Zhdadl5QzY",
ApplicationName = this.GetType().ToString()
});
var searchListRequest = youtubeService.Search.List("snippet");
var titleDescription = RetrieveTitleDescriptionForSearch(imdb.TitleDescription);
searchListRequest.Q = string.Format("{0} {1} trailer", imdb.Title, titleDescription);
searchListRequest.MaxResults = 1;
// Call the search.list method to retrieve results matching the specified query term.
var searchListResponse = searchListRequest.Execute();
youtube.Id = searchListResponse.Items.FirstOrDefault().Id.VideoId;
youtube.Thumbnail = searchListResponse.Items.FirstOrDefault().Snippet.Thumbnails.Default__.Url;
return(youtube);
}
internal static async Task DownloadImdbMetadataAsync(string directory, int level = 2, bool overwrite = false, bool useCache = false, bool useBrowser = false, bool isTV = false, Action <string>?log = null)
{
log ??= TraceLog;
string[] movies = EnumerateDirectories(directory, level).ToArray();
Task[] tasks = Partitioner
.Create(movies)
.GetOrderablePartitions(IOMaxDegreeOfParallelism)
.Select((partition, partitionIndex) => Task.Run(async() =>
{
IWebDriver?webDriver = useBrowser ? WebDriverHelper.Start(partitionIndex) : null;
try
{
if (webDriver is not null)
{
webDriver.Url = "https://www.imdb.com/";
}
await partition.ForEachAsync(async movieWithIndex =>
{
(long index, string movie) = movieWithIndex;
string[] files = Directory.GetFiles(movie, PathHelper.AllSearchPattern, SearchOption.TopDirectoryOnly);
string[] jsonFiles = files.Where(file => file.EndsWith(JsonMetadataExtension, StringComparison.OrdinalIgnoreCase)).ToArray();
if (jsonFiles.Any())
{
if (overwrite)
{
jsonFiles.ForEach(jsonFile =>
{
log($"Delete imdb metadata {jsonFile}.");
File.Delete(jsonFile);
});
}
else
{
log($"Skip {movie}.");
return;
}
}
string?nfo = files.FirstOrDefault(file => file.EndsWith(XmlMetadataExtension, StringComparison.OrdinalIgnoreCase));
if (string.IsNullOrWhiteSpace(nfo))
{
log($"!Missing metadata {movie}.");
return;
}
string imdbId = XDocument.Load(nfo).Root?.Element((isTV ? "imdb_id" : "imdbid") !)?.Value ?? NotExistingFlag;
string imdbFile = Path.Combine(movie, $"{imdbId}{ImdbCacheExtension}");
string parentFile = Path.Combine(movie, $"{imdbId}.Parent{ImdbCacheExtension}");
string releaseFile = Path.Combine(movie, $"{imdbId}.Release{ImdbCacheExtension}");
if (string.Equals(imdbId, NotExistingFlag))
{
if (!files.Any(file => string.Equals(file, imdbFile, StringComparison.OrdinalIgnoreCase)))
{
await File.WriteAllTextAsync(Path.Combine(movie, imdbFile), string.Empty);
}
if (!files.Any(file => string.Equals(file, releaseFile, StringComparison.OrdinalIgnoreCase)))
{
await File.WriteAllTextAsync(Path.Combine(movie, releaseFile), string.Empty);
}
string emptyMetadataFile = Path.Combine(movie, $"{NotExistingFlag}{JsonMetadataExtension}");
if (!files.Any(file => string.Equals(file, emptyMetadataFile, StringComparison.OrdinalIgnoreCase)))
{
await File.WriteAllTextAsync(emptyMetadataFile, "{}");
}
return;
}
log($"{index} Start {movie}");
(string imdbUrl, string imdbHtml, string parentUrl, string parentHtml, string releaseUrl, string releaseHtml, ImdbMetadata imdbMetadata) = await Imdb.DownloadAsync(
imdbId,
useCache,
useCache ? imdbFile : string.Empty,
useCache ? parentFile : string.Empty,
useCache ? releaseFile : string.Empty,
webDriver);
Debug.Assert(!string.IsNullOrWhiteSpace(imdbHtml));
if (!imdbMetadata.Regions.Any())
{
log($"!Location is missing for {imdbId}: {movie}");
}
if (!useCache || !files.Any(file => string.Equals(file, imdbFile, StringComparison.OrdinalIgnoreCase)))
{
log($"Downloaded {imdbUrl} to {imdbFile}.");
await File.WriteAllTextAsync(imdbFile, imdbHtml);
log($"Saved to {imdbFile}.");
}
if (!useCache || !files.Any(file => string.Equals(file, releaseFile, StringComparison.OrdinalIgnoreCase)))
{
log($"Downloaded {releaseUrl} to {releaseFile}.");
await File.WriteAllTextAsync(releaseFile, releaseHtml);
log($"Saved to {releaseFile}.");
}
if (!string.IsNullOrWhiteSpace(parentUrl) && (!useCache || !files.Any(file => string.Equals(file, parentFile, StringComparison.OrdinalIgnoreCase))))
{
log($"Downloaded {parentUrl} to {parentFile}.");
await File.WriteAllTextAsync(parentFile, parentHtml);
log($"Saved to {parentFile}.");
}
string jsonFile = Path.Combine(movie, $"{imdbId}.{imdbMetadata.Year}.{string.Join(",", imdbMetadata.Regions.Take(5))}.{string.Join(",", imdbMetadata.Languages.Take(3))}{JsonMetadataExtension}");
log($"Merged {imdbUrl} and {releaseUrl} to {jsonFile}.");
string jsonContent = JsonSerializer.Serialize(
imdbMetadata,
new JsonSerializerOptions()
{
WriteIndented = true,
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
});
await File.WriteAllTextAsync(jsonFile, jsonContent);
log($"Saved to {jsonFile}.");
});
}
finally
{
webDriver?.Dispose();
}
}))
.ToArray();
await Task.WhenAll(tasks);
}
public MoviesController(IOptions <AppSettings> appSettings)
{
_client = new TMDbClient(appSettings.Value.TmdbApiKey);
_imdb = new Imdb(appSettings.Value.ImdbApiKey);
}
internal static async Task SaveAllVideoMetadata(string jsonPath, Action <string>?log = null, params string[] directories)
{
log ??= TraceLog;
Dictionary <string, Dictionary <string, VideoMetadata> > existingMetadata = File.Exists(jsonPath)
? JsonSerializer.Deserialize <Dictionary <string, Dictionary <string, VideoMetadata> > >(await File.ReadAllTextAsync(jsonPath))
?? throw new InvalidOperationException(jsonPath)
: new();
existingMetadata
.Values
.ForEach(group => group
.Keys
.ToArray()
.Where(video => !File.Exists(Path.IsPathRooted(video) ? video : Path.Combine(Path.GetDirectoryName(jsonPath) ?? string.Empty, video)))
.ForEach(video => group.Remove(video)));
Dictionary <string, string> existingVideos = existingMetadata
.Values
.SelectMany(group => group.Keys)
.ToDictionary(video => video, _ => string.Empty);
Dictionary <string, Dictionary <string, VideoMetadata> > allVideoMetadata = directories
.SelectMany(directory => Directory.GetFiles(directory, JsonMetadataSearchPattern, SearchOption.AllDirectories))
.AsParallel()
.WithDegreeOfParallelism(IOMaxDegreeOfParallelism)
.SelectMany(movieJson =>
{
string relativePath = Path.GetDirectoryName(jsonPath) ?? string.Empty;
Imdb.TryLoad(movieJson, out ImdbMetadata? imdbMetadata);
return(Directory
.GetFiles(Path.GetDirectoryName(movieJson) ?? string.Empty, PathHelper.AllSearchPattern, SearchOption.TopDirectoryOnly)
.Where(video => video.IsCommonVideo() && !existingVideos.ContainsKey(Path.GetRelativePath(relativePath, video)))
.Select(video =>
{
if (!TryGetVideoMetadata(video, out VideoMetadata? videoMetadata, imdbMetadata, relativePath))
{
log($"!Fail: {video}");
}
return videoMetadata;
})
.NotNull());
})
.ToLookup(videoMetadata => videoMetadata.Imdb?.ImdbId ?? string.Empty, metadata => metadata)
.ToDictionary(group => group.Key, group => group.ToDictionary(videoMetadata => videoMetadata.File, videoMetadata => videoMetadata));
allVideoMetadata.ForEach(
group =>
{
if (!existingMetadata.ContainsKey(group.Key))
{
existingMetadata[group.Key] = new();
}
group.Value.ForEach(pair => existingMetadata[group.Key][pair.Key] = pair.Value);
});
existingMetadata
.Keys
.ToArray()
.Where(imdbId => !existingMetadata[imdbId].Any())
.ForEach(imdbId => existingMetadata.Remove(imdbId));
string mergedVideoMetadataJson = JsonSerializer.Serialize(existingMetadata, new() { WriteIndented = true });
await File.WriteAllTextAsync(jsonPath, mergedVideoMetadataJson);
}
internal static void PrintTitlesWithDifferences(string directory, int level = 2, Action <string?>?log = null)
{
log ??= TraceLog;
EnumerateDirectories(directory, level)
.ForEach(movie =>
{
string[] movieName = Path.GetFileName(movie).Split(".");
string movieTitle = movieName[0].Split("=")[0];
string movieYear = movieName[1];
string?videoYear = null;
string?videoTitle = null;
if (Imdb.TryLoad(movie, out ImdbMetadata? jsonMetadata))
{
videoYear = jsonMetadata.Year;
videoTitle = jsonMetadata.Name;
Debug.Assert(videoYear.Length == 4);
}
if (string.IsNullOrWhiteSpace(videoYear))
{
(videoTitle, videoYear) = Directory
.GetFiles(movie, "*.nfo", SearchOption.TopDirectoryOnly)
.Select(metadata =>
{
XElement root = XDocument.Load(metadata).Root ?? throw new InvalidOperationException(metadata);
return(Title: root.Element("title" !)?.Value, Year: root.Element("year" !)?.Value);
})
.Distinct()
.Single();
}
if (!string.Equals(movieYear, videoYear))
{
log(movie);
movieName[1] = videoYear !;
string newMovie = Path.Combine(Path.GetDirectoryName(movie) ?? throw new InvalidOperationException(movie), string.Join(".", movieName));
log(newMovie);
// Directory.Move(movie, newMovie);
string backMovie = movie.Replace(@"E:\", @"F:\");
if (Directory.Exists(backMovie))
{
log(backMovie);
string backupNewMovie = newMovie.Replace(@"E:\", @"F:\");
log(backupNewMovie);
// Directory.Move(backMovie, backupNewMovie);
}
log($"{movieYear}-{movieTitle}");
log($"{videoYear}-{videoTitle}");
log(Environment.NewLine);
}
if (Math.Abs(int.Parse(movieYear) - int.Parse(videoYear !)) > 0)
{
log(movie);
log(movieYear);
log(videoYear);
}
videoTitle = videoTitle?.Replace(Delimiter, string.Empty).Replace(":", string.Empty);
if (string.Equals(videoTitle, movieName[0].Split("=").Last().Replace(SubtitleSeparator, " "), StringComparison.InvariantCultureIgnoreCase))
{
return;
}
if (string.Equals(videoTitle, movieTitle.Split(SubtitleSeparator).Last(), StringComparison.InvariantCultureIgnoreCase))
{
return;
}
movieTitle = movieTitle.Replace(SubtitleSeparator, " ");
if (!string.Equals(videoTitle, movieTitle, StringComparison.InvariantCultureIgnoreCase))
{
log(movie);
log(movieTitle);
log(videoTitle);
log(Environment.NewLine);
}
});
}
internal static void PrintDirectoriesWithErrors(string directory, int level = 2, bool isLoadingVideo = false, bool isNoAudioAllowed = false, Action <string>?log = null)
{
log ??= TraceLog;
List <string>?allVideos = null;
if (isLoadingVideo)
{
allVideos = new();
}
EnumerateDirectories(directory, level)
.ForEach(movie =>
{
string trimmedMovie = Path.GetFileName(movie) ?? throw new InvalidOperationException(movie);
if (trimmedMovie.StartsWith("0."))
{
trimmedMovie = trimmedMovie.Substring("0.".Length);
}
if (trimmedMovie.Contains("{"))
{
trimmedMovie = trimmedMovie.Substring(0, trimmedMovie.IndexOf("{", StringComparison.Ordinal));
}
if (Regex.IsMatch(trimmedMovie, @"·[0-9]"))
{
log($"!Special character ·: {trimmedMovie}");
}
if (trimmedMovie.Contains("："))
{
log($"!Special character ：: {trimmedMovie}");
}
VideoDirectoryInfo videoDirectoryInfo = new(trimmedMovie);
//if (!string.Equals(level1Number1, level1Number3) || !string.IsNullOrWhiteSpace(level1Number2) && !string.Equals(level1Number1, level1Number2))
//{
// log($"{movie}");
//}
//if (Regex.IsMatch(Regex.Replace(match.Groups[5].Value, "([0-9]{1,2})$", ""), "[0-9]+"))
//{
// log($"!Index: {movie}");
//}
new string[] { videoDirectoryInfo.TranslatedTitle1, videoDirectoryInfo.TranslatedTitle2, videoDirectoryInfo.TranslatedTitle3 }
.Where(translated => Regex.IsMatch(translated.Split("`").First(), "[0-9]+"))
.ForEach(translated => log($"!Translation has number {translated}: {movie}"));
string[] files = Directory.EnumerateFiles(movie, PathHelper.AllSearchPattern, SearchOption.TopDirectoryOnly).Select(file => Path.GetFileName(file) ?? throw new InvalidOperationException(file)).ToArray();
if (trimmedMovie.Contains("1080p") && !files.Any(file => file.Contains("1080p")))
{
log($"!Not 1080p: {movie}");
}
if (!trimmedMovie.Contains("1080p") && files.Any(file => file.Contains("1080p")))
{
log($"!1080p: {movie}");
}
if (trimmedMovie.Contains("720p") && !files.Any(file => file.Contains("720p")))
{
log($"!Not 720p: {movie}");
}
if (!trimmedMovie.Contains("1080p") && !trimmedMovie.Contains("720p") && files.Any(file => file.Contains("720p")))
{
log($"!720p: {movie}");
}
string[] videos = files.Where(IsCommonVideo).ToArray();
string[] subtitles = files.Where(file => file.HasAnyExtension(AllSubtitleExtensions)).ToArray();
string[] metadataFiles = files.Where(file => file.HasExtension(XmlMetadataExtension)).ToArray();
string[] imdbFiles = files.Where(file => file.HasExtension(JsonMetadataExtension)).ToArray();
string[] otherFiles = files.Except(videos).Except(subtitles).Except(metadataFiles).Except(imdbFiles).ToArray();
if (videos.Length < 1)
{
log($"!No video: {movie}");
}
else if (videos.Length == 1 || videos.All(video => Regex.IsMatch(Path.GetFileNameWithoutExtension(video), @"\.cd[1-9]$", RegexOptions.IgnoreCase)))
{
string[] allowedAttachments = Attachments.Concat(AdaptiveAttachments).ToArray();
otherFiles
.Where(file => !allowedAttachments.Contains(file, StringComparer.InvariantCultureIgnoreCase))
.ForEach(file => log($"!Attachment: {Path.Combine(movie, file)}"));
}
else
{
string[] allowedAttachments = videos
.SelectMany(video => AdaptiveAttachments.Select(attachment => $"{Path.GetFileNameWithoutExtension(video)}-{attachment}"))
.Concat(Attachments)
.ToArray();
otherFiles
.Where(file => !allowedAttachments.Contains(file, StringComparer.InvariantCultureIgnoreCase))
.ForEach(file => log($"!Attachment: {Path.Combine(movie, file)}"));
}
string[] allowedSubtitles = videos
.SelectMany(video => SubtitleLanguages
.Select(language => $"{Path.GetFileNameWithoutExtension(video)}.{language}")
.Prepend(Path.GetFileNameWithoutExtension(video)))
.SelectMany(subtitle => AllSubtitleExtensions.Select(extension => $"{subtitle}{extension}"))
.ToArray();
subtitles
.Where(subtitle => !allowedSubtitles.Contains(subtitle, StringComparer.InvariantCultureIgnoreCase))
.ForEach(file => log($"!Subtitle: {Path.Combine(movie, file)}"));
string[] allowedMetadataFiles = videos
.Select(video => $"{Path.GetFileNameWithoutExtension(video)}{XmlMetadataExtension}")
.ToArray();
metadataFiles
.Where(metadata => !allowedMetadataFiles.Contains(metadata, StringComparer.InvariantCultureIgnoreCase))
.ForEach(file => log($"!Metadata: {Path.Combine(movie, file)}"));
files
.Except(imdbFiles)
.Where(file => Regex.IsMatch(file, "(1080[^p]|720[^p])"))
.ForEach(file => log($"Definition: {Path.Combine(movie, file)}"));
if (isLoadingVideo)
{
allVideos !.AddRange(videos.Select(video => Path.Combine(movie, video)));
}
if (metadataFiles.Length < 1)
{
log($"!Metadata: {movie}");
}
if (imdbFiles.Length != 1)
{
log($"!Imdb files {imdbFiles.Length}: {movie}");
}
string imdbRating = Imdb.TryLoad(movie, out ImdbMetadata? imdbMetadata)
? imdbMetadata.FormattedAggregateRating
: NotExistingFlag;
if (!string.Equals(videoDirectoryInfo.AggregateRating, imdbRating, StringComparison.InvariantCulture))
{
log($"!Imdb rating {videoDirectoryInfo.AggregateRating} should be {imdbRating}: {movie}");
}
string contentRating = imdbMetadata?.FormattedContentRating ?? NotExistingFlag;
if (!string.Equals(contentRating, videoDirectoryInfo.ContentRating, StringComparison.InvariantCulture))
{
log($"!Content rating {videoDirectoryInfo.ContentRating} should be {contentRating}: {movie}");
}
metadataFiles.ForEach(metadataFile =>
{
metadataFile = Path.Combine(movie, metadataFile);
XDocument metadata = XDocument.Load(Path.Combine(movie, metadataFile));
string?metadataImdbId = metadata.Root?.Element("imdbid")?.Value;
// string? metadataImdbRating = metadata.Root?.Element("rating")?.Value;
if (imdbMetadata == null)
{
if (!string.IsNullOrWhiteSpace(metadataImdbId))
{
log($"!Metadata should have no imdb id: {metadataFile}");
}
// if (!string.IsNullOrWhiteSpace(metadataImdbRating))
// {
// log($"!Metadata should have no rating: {metadataFile}");
// }
}
else
{
if (!string.Equals(imdbMetadata.ImdbId, metadataImdbId))
{
log($"!Metadata imdb id {metadataImdbId} should be {imdbMetadata.ImdbId}: {metadataFile}");
}
}
});
string?imdbYear = imdbMetadata?.Year;
if (!string.IsNullOrWhiteSpace(imdbYear))
{
if (!string.Equals(videoDirectoryInfo.Year, imdbYear))
{
log($"!Year should be {imdbYear}: {movie}");
}
}
string[] directories = Directory.GetDirectories(movie);
if (directories.Length > 1)
{
log($"!Directory {directories.Length}: {movie}");
}
if (directories.Length == 1 && !string.Equals(Featurettes, Path.GetFileName(directories.Single())))
{
log($"!Directory: {directories.Single()}");
}
});
if (isLoadingVideo)
{
PrintVideosWithErrors(allVideos !, isNoAudioAllowed, log);
}
}
public void Download_ReleaseBB_MovieIndex(int StartPage = 1, int LastPage = 1366)
{
_Parse.XML xml = new _Parse.XML();
_Lists lst = new _Lists();
_Sites.Imdb imdb = new Imdb();
string startURL = "http://rlsbb.ru/category/movies/page/";
int LastPageNum = LastPage;
int pageNum = StartPage;
do
{
string URL = startURL + pageNum + "/";
string HTML = ahk.Download_HTML(URL);
string xmlPath = "//*[@id=\"contentArea\"]";
List <string> segs = xml.Parse_HTML_XML(HTML, xmlPath); // extract sections of text from html xml
int segNum = 1;
foreach (string seg in segs)
{
ReleaseBBMovies obj = new ReleaseBBMovies();
// skip segs on page that aren't posts
if (segNum == 1)
{
segNum++; continue;
}
if (segNum == 2)
{
segNum++; continue;
}
if (segNum == 13)
{
segNum++; continue;
}
if (segNum == 14)
{
segNum++; continue;
}
//ahk.MsgBox(segNum + " | " + seg);
segNum++;
string PostTitle = "";
string PostURL = "";
string IMDbID = "";
List <string> links = imdb.Regex_IMDbLinks(seg);
if (links.Count > 0)
{
IMDbID = imdb.IMDb_ID_FromURL(links[0]);
}
// parse index page segment
List <string> lines = lst.Text_To_List(seg, true, true, false);
foreach (string line in lines)
{
if (line.Contains("postTitle"))
{
PostURL = line.Replace("<h2 class=\"postTitle\"><span></span><a href=\"", "");
PostTitle = ahk.StringSplit(PostURL, ">", 1);
PostTitle = ahk.StringSplit(PostTitle, "<", 0);
PostURL = ahk.StringSplit(PostURL, "\"", 0);
//ahk.MsgBox("IMDB: " + IMDbID + "\n\n" + PostTitle + "\n\n" + PostURL);
}
}
obj.IMDbID = IMDbID;
obj.PostTitle = PostTitle;
obj.PostURL = PostURL;
bool Updated = ReleaseBBMovies_UpdateInsert_IndexEntry(obj);
}
pageNum++;
}while (pageNum <= LastPageNum);
}
internal static async Task DownloadImdbMetadataAsync(string directory, int level = 2, bool overwrite = false, bool isTV = false, Action <string>?log = null)
{
log ??= TraceLog;
await EnumerateDirectories(directory, level)
.ParallelForEachAsync(async movie =>
{
if (!overwrite && Directory.EnumerateFiles(movie, JsonMetadataSearchPattern, SearchOption.TopDirectoryOnly).Any())
{
log($"Skip {movie}.");
return;
}
string?nfo = Directory.EnumerateFiles(movie, XmlMetadataSearchPattern, SearchOption.TopDirectoryOnly).FirstOrDefault();
if (string.IsNullOrWhiteSpace(nfo))
{
log($"!Missing metadata {movie}.");
return;
}
string?imdbId = XDocument.Load(nfo).Root?.Element((isTV ? "imdb_id" : "imdbid") !)?.Value;
if (string.IsNullOrWhiteSpace(imdbId))
{
await File.WriteAllTextAsync(Path.Combine(movie, $"{NotExistingFlag}{JsonMetadataExtension}"), "{}");
return;
}
(string imdbJson, string year, string[] regions) = await Retry.FixedIntervalAsync(async() => await Imdb.DownloadJsonAsync($"https://www.imdb.com/title/{imdbId}"), retryCount: 10);
Debug.Assert(!string.IsNullOrWhiteSpace(imdbJson));
if (string.IsNullOrWhiteSpace(year))
{
ImdbMetadata imdbMetadata = JsonSerializer.Deserialize <ImdbMetadata>(
imdbJson,
new() { PropertyNameCaseInsensitive = true, IgnoreReadOnlyProperties = true }) ?? throw new InvalidOperationException(imdbJson);
year = imdbMetadata.YearOfCurrentRegion;
}
if (string.IsNullOrWhiteSpace(year))
{
log($"!Year is missing for {imdbId}: {movie}");
}
if (!regions.Any())
{
log($"!Location is missing for {imdbId}: {movie}");
}
string json = Path.Combine(movie, $"{imdbId}.{year}.{string.Join(",", regions.Take(5))}{JsonMetadataExtension}");
log($"Downloaded https://www.imdb.com/title/{imdbId} to {json}.");
await File.WriteAllTextAsync(json, imdbJson);
log($"Saved to {json}.");
}, IOMaxDegreeOfParallelism);
}
