public UpdateResults Update(DBMovieInfo movie)
{
throw new NotImplementedException();
}
public static Backdrop FromUrl(DBMovieInfo movie, string url, out ImageLoadResults status)
{
return(FromUrl(movie, url, false, out status));
}
public int Compare(GUIListItem x, GUIListItem y)
{
try {
DBMovieInfo movieX = (DBMovieInfo)x.TVTag;
DBMovieInfo movieY = (DBMovieInfo)y.TVTag;
int rtn;
switch (_sortField)
{
case SortingFields.DateAdded:
rtn = movieX.DateAdded.CompareTo(movieY.DateAdded);
break;
case SortingFields.ReleaseDate:
rtn = movieX.ReleaseDate.CompareTo(movieY.ReleaseDate);
break;
case SortingFields.Year:
rtn = movieX.Year.CompareTo(movieY.Year);
break;
case SortingFields.Certification:
int intX = GetCertificationValue(movieX.Certification);
int intY = GetCertificationValue(movieY.Certification);
if (intX == 100 && intY == 100)
{
rtn = movieX.Certification.CompareTo(movieY.Certification);
}
else
{
rtn = intX.CompareTo(intY);
}
break;
case SortingFields.Language:
rtn = movieX.Language.CompareTo(movieY.Language);
break;
case SortingFields.Score:
rtn = movieX.Score.CompareTo(movieY.Score);
break;
case SortingFields.Runtime:
rtn = movieX.Runtime.CompareTo(movieY.Runtime);
break;
case SortingFields.FilePath:
rtn = movieX.LocalMedia[0].FullPath.CompareTo(movieY.LocalMedia[0].FullPath);
break;
case SortingFields.FileSize:
rtn = movieX.LocalMedia[0].FileSize.CompareTo(movieY.LocalMedia[0].FileSize);
break;
// default to the title field
case SortingFields.Title:
default:
rtn = movieX.SortBy.CompareTo(movieY.SortBy);
break;
}
// if both items are identical, fallback to using the Title
if (rtn == 0)
{
rtn = movieX.SortBy.CompareTo(movieY.SortBy);
}
// if both items are STILL identical, fallback to using the ID
if (rtn == 0)
{
rtn = movieX.ID.GetValueOrDefault(0).CompareTo(movieY.ID.GetValueOrDefault(0));
}
if (_sortDirection == SortingDirections.Descending)
{
rtn = -rtn;
}
return(rtn);
}
catch {
return(0);
}
}
private DBMovieInfo getMovieDetails(string mmid)
{
FilmDetail film = Api.GetMovieDetails(mmid);
if (film != null)
{
DBMovieInfo movie = new DBMovieInfo();
movie.GetSourceMovieInfo(SourceInfo).Identifier = film.filmId.ToString();
movie.Title = film.title.FromSortable();
movie.Summary = film.plot;
movie.ImdbID = "tt" + film.imdb;
movie.DetailsURL = film.url;
// Score (multiply by 2 to get the 1-10 scale)
if (!String.IsNullOrEmpty(film.average))
{
movie.Score = (Convert.ToSingle(film.average, NumberFormatInfo.InvariantInfo) * 2);
}
// Runtime
int runtime = 0;
if (int.TryParse(film.duration, out runtime))
{
movie.Runtime = runtime;
}
// Year
int year = 0;
if (int.TryParse(film.year, out year))
{
movie.Year = year;
}
// Try to add the alternative titles
if (film.alternative_titles != null)
{
foreach (FilmDetail.Title alt in film.alternative_titles)
{
movie.AlternateTitles.Add(alt.title);
}
}
// Try to add the genres
if (film.genres != null)
{
foreach (string genre in film.genres)
{
movie.Genres.Add(genre);
}
}
// Try to add the actors
if (film.actors != null)
{
foreach (FilmDetail.Actor actor in film.actors)
{
movie.Actors.Add(actor.name);
}
}
// Try to add the directors
if (film.directors != null)
{
foreach (FilmDetail.Director director in film.directors)
{
movie.Directors.Add(director.name);
}
}
return(movie);
}
return(null);
}
private void clearMovieResumeState(DBMovieInfo movie)
{
updateMovieResumeState(movie, 0, 0, null, 0);
}
public bool GetArtwork(DBMovieInfo movie)
{
if (movie == null)
{
return(false);
}
// do we have an id?
string movieId = getMovieId(movie);
if (string.IsNullOrEmpty(movieId))
{
return(false);
}
string url = apiMovieArtwork;
if (!string.IsNullOrEmpty(MovingPicturesCore.Settings.FanartTVClientKey))
{
url = url + "&client_key=" + MovingPicturesCore.Settings.FanartTVClientKey;
}
// try to get movie artwork
string response = getJson(string.Format(apiMovieArtwork, movieId));
if (response == null)
{
return(false);
}
// de-serialize json response
var movieImages = response.FromJson <Artwork>();
if (movieImages == null)
{
return(false);
}
// check if we have any posters
if (movieImages.movieposter == null || movieImages.movieposter.Count == 0)
{
return(false);
}
// filter posters by language
var langPosters = movieImages.movieposter.Where(p => p.lang == MovingPicturesCore.Settings.DataProviderLanguageCode);
// if no localised posters available use all posters
if (langPosters.Count() == 0)
{
langPosters = movieImages.movieposter;
}
// sort by highest rated / most popular
langPosters = langPosters.OrderByDescending(p => p.likes);
// grab coverart loading settings
int maxCovers = MovingPicturesCore.Settings.MaxCoversPerMovie;
int maxCoversInSession = MovingPicturesCore.Settings.MaxCoversPerSession;
int coversAdded = 0;
// download posters
foreach (var poster in langPosters)
{
// if we have hit our limit quit
if (movie.AlternateCovers.Count >= maxCovers || coversAdded >= maxCoversInSession)
{
return(true);
}
// get url for cover and load it via the movie object
string coverPath = poster.url;
if (coverPath.Trim() != string.Empty)
{
if (movie.AddCoverFromURL(coverPath) == ImageLoadResults.SUCCESS)
{
coversAdded++;
}
}
}
if (coversAdded > 0)
{
// Update source info
movie.GetSourceMovieInfo(SourceInfo).Identifier = movieId;
return(true);
}
return(false);
}
public UpdateResults Update(DBMovieInfo movie)
{
if (scraper == null)
{
return(UpdateResults.FAILED);
}
Dictionary <string, string> paramList = new Dictionary <string, string>();
Dictionary <string, string> results;
bool hasSiteId = false;
// try to load the id for the movie for this script
// if we have no site id still continue as we might still
// be able to grab details using another identifier such as imdb_id
DBSourceMovieInfo idObj = movie.GetSourceMovieInfo(ScriptID);
if (idObj != null && idObj.Identifier != null)
{
paramList["movie.site_id"] = idObj.Identifier;
hasSiteId = true;
}
// load params
foreach (DBField currField in DBField.GetFieldList(typeof(DBMovieInfo)))
{
if (currField.AutoUpdate && currField.GetValue(movie) != null)
{
paramList["movie." + currField.FieldName] = currField.GetValue(movie).ToString().Trim();
}
}
//set higher level settings for script to use
paramList["settings.defaultuseragent"] = MovingPicturesCore.Settings.UserAgent;
paramList["settings.mepo_data"] = Config.GetFolder(Config.Dir.Config);
// try to retrieve results
results = scraper.Execute("get_details", paramList);
if (results == null)
{
logger.Error(Name + " scraper script failed to execute \"get_details\" node.");
return(UpdateResults.FAILED);
}
if (!hasSiteId)
{
// if we started out without a site id
// try to get it from the details response
string siteId;
if (results.TryGetValue("movie.site_id", out siteId))
{
movie.GetSourceMovieInfo(ScriptID).Identifier = siteId;
}
else
{
// still no site id, so we are returning
return(UpdateResults.FAILED_NEED_ID);
}
}
// get our new movie details
DBMovieInfo newMovie = new DBMovieInfo();
foreach (DBField currField in DBField.GetFieldList(typeof(DBMovieInfo)))
{
string value;
bool success = results.TryGetValue("movie." + currField.FieldName, out value);
if (success && value.Trim().Length > 0)
{
currField.SetValue(newMovie, value.Trim());
}
}
// and update as necessary
movie.CopyUpdatableValues(newMovie);
return(UpdateResults.SUCCESS);
}
public void Play(DBMovieInfo movie)
{
Play(movie, 1);
}
public RenamableFile(DBMovieInfo movie, FileInfo originalFile)
{
_movie = movie;
_originalFile = originalFile;
_originalName = originalFile.FullName;
}
public List <DBMovieInfo> Get(MovieSignature movieSignature)
{
if (scraper == null)
{
return(null);
}
List <DBMovieInfo> rtn = new List <DBMovieInfo>();
Dictionary <string, string> paramList = new Dictionary <string, string>();
Dictionary <string, string> results;
if (movieSignature.Title != null)
{
paramList["search.title"] = movieSignature.Title;
}
if (movieSignature.Keywords != null)
{
paramList["search.keywords"] = movieSignature.Keywords;
}
if (movieSignature.Year != null)
{
paramList["search.year"] = movieSignature.Year.ToString();
}
if (movieSignature.ImdbId != null)
{
paramList["search.imdb_id"] = movieSignature.ImdbId;
}
if (movieSignature.DiscId != null)
{
paramList["search.disc_id"] = movieSignature.DiscId;
}
if (movieSignature.MovieHash != null)
{
paramList["search.moviehash"] = movieSignature.MovieHash;
}
if (movieSignature.Path != null)
{
paramList["search.basepath"] = movieSignature.Path;
}
if (movieSignature.Folder != null)
{
paramList["search.foldername"] = movieSignature.Folder;
}
if (movieSignature.File != null)
{
paramList["search.filename"] = movieSignature.File;
}
//set higher level settings for script to use
paramList["settings.defaultuseragent"] = MovingPicturesCore.Settings.UserAgent;
paramList["settings.mepo_data"] = Config.GetFolder(Config.Dir.Config);
// this variable is the filename without extension (and a second one without stackmarkers)
if (!String.IsNullOrEmpty(movieSignature.File))
{
paramList["search.filename_noext"] = Path.GetFileNameWithoutExtension(movieSignature.File);
paramList["search.clean_filename"] = Utility.GetFileNameWithoutExtensionAndStackMarkers(movieSignature.File);
}
results = scraper.Execute("search", paramList);
if (results == null)
{
logger.Error(Name + " scraper script failed to execute \"search\" node.");
return(rtn);
}
int count = 0;
// The movie result is only valid if the script supplies a unique site
while (results.ContainsKey("movie[" + count + "].site_id"))
{
string siteId;
string prefix = "movie[" + count + "].";
count++;
// if the result does not yield a site id it's not valid so skip it
if (!results.TryGetValue(prefix + "site_id", out siteId))
{
continue;
}
// if this movie was already added skip it
if (rtn.Exists(delegate(DBMovieInfo item) { return(item.GetSourceMovieInfo(ScriptID).Identifier == siteId); }))
{
continue;
}
// if this movie does not have a valid title, don't bother
if (!results.ContainsKey(prefix + "title"))
{
continue;
}
// We passed all checks so create a new movie object
DBMovieInfo newMovie = new DBMovieInfo();
// store the site id in the new movie object
newMovie.GetSourceMovieInfo(ScriptID).Identifier = siteId;
// Try to store all other fields in the new movie object
foreach (DBField currField in DBField.GetFieldList(typeof(DBMovieInfo)))
{
string value;
if (results.TryGetValue(prefix + currField.FieldName, out value))
{
currField.SetValue(newMovie, value.Trim());
}
}
// add the movie to our movie results list
rtn.Add(newMovie);
}
return(rtn);
}
public SingleMovieImporterPopup(DBMovieInfo movie)
{
InitializeComponent();
localMedia = new List <DBLocalMedia>(movie.LocalMedia);
movie.Delete();
}
public bool Rename(DBMovieInfo movie)
{
return(GetRenameActionList(movie).RenameApprovedItems());
}
private DBMovieInfo getMovieInfo(string idMovie)
{
DBMovieInfo movieRes = new DBMovieInfo();
try
{
SQLiteClient mp_db = new SQLiteClient(Config.GetFile(Config.Dir.Database, @"VideoDatabaseV5.db3"));
SQLiteResultSet sqlResults = mp_db.Execute("SELECT * FROM movieinfo WHERE idMovie LIKE '" + idMovie + "'");
SQLiteResultSet.Row sqlRow = sqlResults.GetRow(0);
System.Collections.Hashtable columns = sqlResults.ColumnIndices;
movieRes.Popularity = int.Parse(sqlResults.GetField(0, int.Parse(columns["strVotes"].ToString())));
movieRes.Runtime = int.Parse(sqlResults.GetField(0, int.Parse(columns["runtime"].ToString())));
movieRes.Score = float.Parse(sqlResults.GetField(0, int.Parse(columns["fRating"].ToString())));
movieRes.Year = int.Parse(sqlResults.GetField(0, int.Parse(columns["iYear"].ToString())));
string Title = sqlResults.GetField(0, int.Parse(columns["strTitle"].ToString()));
if (!Title.Contains("unknown"))
{
movieRes.Title = Title;
}
string Certification = sqlResults.GetField(0, int.Parse(columns["mpaa"].ToString()));
if (!Certification.Contains("unknown"))
{
movieRes.Certification = Certification;
}
string Tagline = sqlResults.GetField(0, int.Parse(columns["strTagLine"].ToString()));
if (!Tagline.Contains("unknown"))
{
movieRes.Tagline = Tagline;
}
string Summary = sqlResults.GetField(0, int.Parse(columns["strPlotOutline"].ToString()));
if (!Summary.Contains("unknown"))
{
movieRes.Summary = Summary;
}
string imdb_id = sqlResults.GetField(0, int.Parse(columns["IMDBID"].ToString()));
if (!imdb_id.Contains("unknown"))
{
movieRes.ImdbID = imdb_id;
}
string genreMain = sqlResults.GetField(0, int.Parse(columns["strGenre"].ToString()));
if (!genreMain.Contains("unknown"))
{
string[] genreSplit = genreMain.Split('/');
foreach (string genre in genreSplit)
{
movieRes.Genres.Add(genre.Trim());
}
}
string castMain = sqlResults.GetField(0, int.Parse(columns["strCast"].ToString()));
if (!castMain.Contains("unknown"))
{
string[] castSplit = castMain.Split('\n');
foreach (string cast in castSplit)
{
string castFinal = cast;
if (cast.Contains(" as "))
{
castFinal = cast.Remove(cast.IndexOf(" as "));
}
movieRes.Actors.Add(castFinal.Trim());
}
}
string idDirector = sqlResults.GetField(0, int.Parse(columns["idDirector"].ToString()));
if (!castMain.Contains("unknown"))
{
SQLiteResultSet sqlDirector = mp_db.Execute("SELECT strActor FROM actors WHERE idActor LIKE '" + idDirector + "'");
movieRes.Directors.Add(sqlDirector.GetField(0, 0));
}
string writers = sqlResults.GetField(0, int.Parse(columns["strCredits"].ToString()));
if (!writers.Contains("unknown"))
{
string[] writerArray = writers.Split(new string[] { "\n", " " }, StringSplitOptions.None);
foreach (string writer in writerArray)
{
if (!movieRes.Writers.Contains(writer.Trim()))
{
movieRes.Writers.Add(writer.Trim());
}
}
}
movieRes.GetSourceMovieInfo(SourceInfo).Identifier = sqlResults.GetField(0, int.Parse(columns["idMovie"].ToString())).ToString();
mp_db.Close();
}
catch
{
return(null);
}
return(movieRes);
}
public static Cover FromFile(DBMovieInfo movie, string path)
{
throw new NotImplementedException();
}
public bool GetArtwork(DBMovieInfo movie)
{
if (scraper == null)
{
return(false);
}
Dictionary <string, string> paramList = new Dictionary <string, string>();
Dictionary <string, string> results;
// grab coverart loading settings
int maxCovers = MovingPicturesCore.Settings.MaxCoversPerMovie;
int maxCoversInSession = MovingPicturesCore.Settings.MaxCoversPerSession;
// if we have already hit our limit for the number of covers to load, quit
if (movie.AlternateCovers.Count >= maxCovers)
{
return(true);
}
// try to load the id for the movie for this script
DBSourceMovieInfo idObj = movie.GetSourceMovieInfo(ScriptID);
if (idObj != null && idObj.Identifier != null)
{
paramList["movie.site_id"] = idObj.Identifier;
}
// load params for scraper
foreach (DBField currField in DBField.GetFieldList(typeof(DBMovieInfo)))
{
if (currField.GetValue(movie) != null)
{
paramList["movie." + currField.FieldName] = currField.GetValue(movie).ToString().Trim();
}
}
//set higher level settings for script to use
paramList["settings.defaultuseragent"] = MovingPicturesCore.Settings.UserAgent;
paramList["settings.mepo_data"] = Config.GetFolder(Config.Dir.Config);
// run the scraper
results = scraper.Execute("get_cover_art", paramList);
if (results == null)
{
logger.Error(Name + " scraper script failed to execute \"get_cover_art\" node.");
return(false);
}
int coversAdded = 0;
int count = 0;
while (results.ContainsKey("cover_art[" + count + "].url") || results.ContainsKey("cover_art[" + count + "].file"))
{
// if we have hit our limit quit
if (movie.AlternateCovers.Count >= maxCovers || coversAdded >= maxCoversInSession)
{
return(true);
}
// get url for cover and load it via the movie object
if (results.ContainsKey("cover_art[" + count + "].url"))
{
string coverPath = results["cover_art[" + count + "].url"];
if (coverPath.Trim() != string.Empty)
{
if (movie.AddCoverFromURL(coverPath) == ImageLoadResults.SUCCESS)
{
coversAdded++;
}
}
}
// get file for cover and load it via the movie object
if (results.ContainsKey("cover_art[" + count + "].file"))
{
string coverPath = results["cover_art[" + count + "].file"];
if (coverPath.Trim() != string.Empty)
{
if (movie.AddCoverFromFile(coverPath))
{
coversAdded++;
}
}
}
count++;
}
if (coversAdded > 0)
{
return(true);
}
return(false);
}
private LatestsCollection GetLatestMovingPictures()
{
latestMovies = new LatestsCollection();
latestMovingPictures = new Hashtable();
LatestsCollection latests = new LatestsCollection();
try
{
List <DBMovieInfo> vMovies = null;
if (Restricted)
{
vMovies = MovingPicturesCore.Settings.ParentalControlsFilter.Filter(DBMovieInfo.GetAll()).ToList();
}
else
{
vMovies = DBMovieInfo.GetAll();
}
foreach (var item in vMovies)
{
if (CurrentFacade.Type == LatestsFacadeType.Watched)
{
if (item.UserSettings[0].WatchedCount == 0)
{
continue;
}
}
else if (CurrentFacade.UnWatched && (item.UserSettings[0].WatchedCount > 0))
{
continue;
}
if (CurrentFacade.Type == LatestsFacadeType.Rated)
{
if (item.Score == 0.0)
{
continue;
}
}
string sTimestamp = item.DateAdded.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.CurrentCulture);
string fanart = item.CoverThumbFullPath;
if (string.IsNullOrEmpty(fanart))
{
fanart = "DefaultVideoBig.png"; // "DefaultFolderBig.png";
}
string fbanner = string.Empty;
string fclearart = string.Empty;
string fclearlogo = string.Empty;
string fcd = string.Empty;
string aposter = string.Empty;
string abg = string.Empty;
if (Utils.FanartHandler)
{
Parallel.Invoke
(
() => fbanner = UtilsFanartHandler.GetFanartTVForLatestMedia(item.ImdbID, string.Empty, string.Empty, Utils.FanartTV.MoviesBanner),
() => fclearart = UtilsFanartHandler.GetFanartTVForLatestMedia(item.ImdbID, string.Empty, string.Empty, Utils.FanartTV.MoviesClearArt),
() => fclearlogo = UtilsFanartHandler.GetFanartTVForLatestMedia(item.ImdbID, string.Empty, string.Empty, Utils.FanartTV.MoviesClearLogo),
() => fcd = UtilsFanartHandler.GetFanartTVForLatestMedia(item.ImdbID, string.Empty, string.Empty, Utils.FanartTV.MoviesCDArt),
() => aposter = UtilsFanartHandler.GetAnimatedForLatestMedia(item.ImdbID, string.Empty, string.Empty, Utils.Animated.MoviesPoster),
() => abg = UtilsFanartHandler.GetAnimatedForLatestMedia(item.ImdbID, string.Empty, string.Empty, Utils.Animated.MoviesBackground)
);
}
latests.Add(new Latest(sTimestamp, fanart, item.BackdropFullPath, item.Title,
null, null, null,
item.Genres.ToPrettyString(2),
item.Score.ToString(CultureInfo.CurrentCulture),
Math.Round(item.Score, MidpointRounding.AwayFromZero).ToString(CultureInfo.CurrentCulture),
item.Certification, GetMovieRuntime(item), item.Year.ToString(CultureInfo.CurrentCulture),
null, null, null,
item, item.ID.ToString(), item.Summary,
null,
fbanner, fclearart, fclearlogo, fcd,
aposter, abg));
if (item.WatchedHistory.Count > 0)
{
latests[latests.Count - 1].DateWatched = item.WatchedHistory[item.WatchedHistory.Count - 1].DateWatched.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.CurrentCulture);
}
Utils.ThreadToSleep();
}
if (vMovies != null)
{
vMovies.Clear();
}
vMovies = null;
CurrentFacade.HasNew = false;
Utils.SortLatests(ref latests, CurrentFacade.Type, CurrentFacade.LeftToRight);
int x = 0;
for (int x0 = 0; x0 < latests.Count; x0++)
{
try
{
DateTime dTmp = DateTime.Parse(latests[x0].DateAdded);
latests[x0].DateAdded = String.Format("{0:" + Utils.DateFormat + "}", dTmp);
DBMovieInfo Movie = (DBMovieInfo)latests[x0].Playable;
latests[x0].IsNew = ((dTmp > Utils.NewDateTime) && (Movie.UserSettings[0].WatchedCount <= 0));
if (latests[x0].IsNew)
{
CurrentFacade.HasNew = true;
}
}
catch
{ }
latestMovies.Add(latests[x0]);
latestMovingPictures.Add(x0 + 1, latests[x0].Playable);
Utils.ThreadToSleep();
// logger.Debug("*** Latest [{7}] {0}:{1}:{2} - {3} - {4} {5} - {6}", x, CurrentFacade.Type, CurrentFacade.LeftToRight, latests[x0].Title, latests[x0].DateAdded, latests[x0].DateWatched, latests[x0].Rating, CurrentFacade.ControlID);
x++;
if (x == Utils.FacadeMaxNum)
{
break;
}
}
}
catch (Exception ex)
{
logger.Error("GetLatestMovingPictures: " + ex.ToString());
}
if (latests != null)
{
latests.Clear();
}
latests = null;
if (latestMovies != null && !MainFacade)
{
logger.Debug("GetLatest: " + this.ToString() + ":" + CurrentFacade.ControlID + " - " + latestMovies.Count);
}
return(latestMovies);
}
public bool GetBackdrop(DBMovieInfo movie)
{
if (scraper == null)
{
return(false);
}
Dictionary <string, string> paramList = new Dictionary <string, string>();
Dictionary <string, string> results;
// if we already have a backdrop move on for now
if (movie.BackdropFullPath.Trim().Length > 0)
{
return(true);
}
// try to load the id for the movie for this script
DBSourceMovieInfo idObj = movie.GetSourceMovieInfo(ScriptID);
if (idObj != null && idObj.Identifier != null)
{
paramList["movie.site_id"] = idObj.Identifier;
}
// load params for scraper
foreach (DBField currField in DBField.GetFieldList(typeof(DBMovieInfo)))
{
if (currField.GetValue(movie) != null)
{
paramList["movie." + currField.FieldName] = currField.GetValue(movie).ToString().Trim();
}
}
//set higher level settings for script to use
paramList["settings.defaultuseragent"] = MovingPicturesCore.Settings.UserAgent;
paramList["settings.mepo_data"] = Config.GetFolder(Config.Dir.Config);
// run the scraper
results = scraper.Execute("get_backdrop", paramList);
if (results == null)
{
logger.Error(Name + " scraper script failed to execute \"get_backdrop\" node.");
return(false);
}
// Loop through all the results until a valid backdrop is found
int count = 0;
while (results.ContainsKey("backdrop[" + count + "].url") || results.ContainsKey("backdrop[" + count + "].file"))
{
// attempt to load via a URL
if (results.ContainsKey("backdrop[" + count + "].url"))
{
string backdropURL = results["backdrop[" + count + "].url"];
if (backdropURL.Trim().Length > 0)
{
if (movie.AddBackdropFromURL(backdropURL) == ImageLoadResults.SUCCESS)
{
return(true);
}
}
}
// attempt to load via a file
if (results.ContainsKey("backdrop[" + count + "].file"))
{
string backdropFile = results["backdrop[" + count + "].file"];
if (backdropFile.Trim().Length > 0)
{
if (movie.AddBackdropFromFile(backdropFile))
{
return(true);
}
}
}
count++;
}
// no valid backdrop found
return(false);
}
private void playMovie(DBMovieInfo movie, int requestedPart)
{
logger.Debug("playMovie()");
_playerState = MoviePlayerState.Processing;
if (movie == null || requestedPart > movie.LocalMedia.Count || requestedPart < 1)
{
resetPlayer();
return;
}
logger.Debug("Request: Movie='{0}', Part={1}", movie.Title, requestedPart);
for (int i = 0; i < movie.LocalMedia.Count; i++)
{
logger.Debug("LocalMedia[{0}] = {1}, Duration = {2}", i, movie.LocalMedia[i].FullPath, movie.LocalMedia[i].Duration);
}
int part = requestedPart;
// if this is a request to start the movie from the beginning, check if we should resume
// or prompt the user for disk selection
if (requestedPart == 1)
{
// check if we should be resuming, and if not, clear resume data
_resumeActive = PromptUserToResume(movie);
if (_resumeActive)
{
part = movie.ActiveUserSettings.ResumePart;
}
else
{
clearMovieResumeState(movie);
}
// if we have a multi-part movie composed of disk images and we are not resuming
// ask which part the user wants to play
if (!_resumeActive && movie.LocalMedia.Count > 1 && (movie.LocalMedia[0].IsImageFile || movie.LocalMedia[0].IsVideoDisc))
{
GUIDialogFileStacking dlg = (GUIDialogFileStacking)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_FILESTACKING);
if (null != dlg)
{
dlg.SetNumberOfFiles(movie.LocalMedia.Count);
dlg.DoModal(GUIWindowManager.ActiveWindow);
part = dlg.SelectedFile;
if (part < 1)
{
resetPlayer();
return;
}
}
}
}
DBLocalMedia mediaToPlay = movie.LocalMedia[part - 1];
MediaState mediaState = mediaToPlay.State;
while (mediaState != MediaState.Online)
{
switch (mediaState)
{
case MediaState.Removed:
_gui.ShowMessage("Error", Translation.MediaIsMissing);
resetPlayer();
return;
case MediaState.Offline:
string bodyString = String.Format(Translation.MediaNotAvailableBody, mediaToPlay.MediaLabel);
// Special debug line to troubleshoot availability issues
logger.Debug("Media not available: Path={0}, DriveType={1}, Serial={2}, ExpectedSerial={3}",
mediaToPlay.FullPath, mediaToPlay.ImportPath.GetDriveType().ToString(),
mediaToPlay.ImportPath.GetVolumeSerial(), mediaToPlay.VolumeSerial);
// Prompt user to enter media
if (!_gui.ShowCustomYesNo(Translation.MediaNotAvailableHeader, bodyString, Translation.Retry, Translation.Cancel, true))
{
// user cancelled so exit
resetPlayer();
return;
}
break;
case MediaState.NotMounted:
// Mount this media
MountResult result = mediaToPlay.Mount();
while (result == MountResult.Pending)
{
if (_gui.ShowCustomYesNo(Translation.VirtualDriveHeader, Translation.VirtualDriveMessage, Translation.Retry, Translation.Cancel, true))
{
// User has chosen to retry
// We stay in the mount loop
result = mediaToPlay.Mount();
}
else
{
// Exit the player
resetPlayer();
return;
}
}
// If the mounting failed (can not be solved within the loop) show error and return
if (result == MountResult.Failed)
{
_gui.ShowMessage(Translation.Error, Translation.FailedMountingImage);
// Exit the player
resetPlayer();
return;
}
// Mounting was succesfull, break the mount loop
break;
}
// Check mediaState again
mediaState = mediaToPlay.State;
}
// Get the path to the playable video.
string videoPath = mediaToPlay.GetVideoPath();
// If the media is an image, it will be mounted by this point so
// we flag the mounted playback variable
mountedPlayback = mediaToPlay.IsImageFile;
// if we do not have MediaInfo but have the AutoRetrieveMediaInfo setting toggled
// get the media info
if (!mediaToPlay.HasMediaInfo && MovingPicturesCore.Settings.AutoRetrieveMediaInfo)
{
mediaToPlay.UpdateMediaInfo();
mediaToPlay.Commit();
}
// store the current media object so we can request it later
queuedMedia = mediaToPlay;
// start playback
if (_resumeActive && movie.LocalMedia[0].IsBluray)
{
_forcePlay = true;
g_Player.SetResumeBDTitleState = movie.ActiveUserSettings.ResumeTitleBD;
}
logger.Info("Playing: Movie='{0}' FullPath='{1}', VideoPath='{2}', Mounted='{3}'", movie.Title, mediaToPlay.FullPath, videoPath, mountedPlayback.ToString());
playFile(videoPath, mediaToPlay.VideoFormat);
}
public bool GetArtwork(DBMovieInfo movie)
{
if (movie == null)
{
return(false);
}
// do we have an id?
string tmdbID = getTheMovieDbId(movie, true);
if (tmdbID == null)
{
return(false);
}
// try to get movie artwork
var movieArtwork = TheMovieDbAPI.GetMovieImages(tmdbID);
if (movieArtwork == null || movieArtwork.Posters == null || movieArtwork.Posters.Count == 0)
{
return(false);
}
// filter out minimum size images
int minWidth = MovingPicturesCore.Settings.MinimumCoverWidth;
int minHeight = MovingPicturesCore.Settings.MinimumCoverHeight;
movieArtwork.Posters.RemoveAll(p => p.Width < minWidth || p.Height < minHeight);
if (movieArtwork.Posters.Count == 0)
{
return(false);
}
// filter posters by language
var langPosters = movieArtwork.Posters.Where(p => p.LanguageCode == MovingPicturesCore.Settings.DataProviderLanguageCode);
if (MovingPicturesCore.Settings.DataProviderLanguageCode == "en")
{
// include no language posters with english (sometimes language is not assigned)
langPosters = langPosters.Union(movieArtwork.Posters.Where(p => p.LanguageCode == null));
}
// if no localised posters available use all posters
if (langPosters.Count() == 0)
{
langPosters = movieArtwork.Posters;
}
// sort by highest rated / most popular
langPosters = langPosters.OrderByDescending(p => p.Score);
// grab coverart loading settings
int maxCovers = MovingPicturesCore.Settings.MaxCoversPerMovie;
int maxCoversInSession = MovingPicturesCore.Settings.MaxCoversPerSession;
int coversAdded = 0;
// get the base url for images
string baseImageUrl = getImageBaseUrl();
if (string.IsNullOrEmpty(baseImageUrl))
{
return(false);
}
// download posters
foreach (var poster in langPosters)
{
// if we have hit our limit quit
if (movie.AlternateCovers.Count >= maxCovers || coversAdded >= maxCoversInSession)
{
return(true);
}
// get url for cover and load it via the movie object
string coverPath = baseImageUrl + poster.FilePath;
if (coverPath.Trim() != string.Empty)
{
if (movie.AddCoverFromURL(coverPath) == ImageLoadResults.SUCCESS)
{
coversAdded++;
}
}
}
if (coversAdded > 0)
{
// Update source info
movie.GetSourceMovieInfo(SourceInfo).Identifier = tmdbID;
return(true);
}
return(false);
}
public UpdateResults Update(DBMovieInfo movie)
{
return(UpdateResults.FAILED);
}
private DBMovieInfo getMovieInformation(string movieId)
{
if (string.IsNullOrEmpty(movieId))
{
return(null);
}
// request the movie details by imdb id or tmdb id
var movieDetails = TheMovieDbAPI.GetMovieInfo(movieId, MovingPicturesCore.Settings.DataProviderLanguageCode);
if (movieDetails == null)
{
return(null);
}
var movie = new DBMovieInfo();
// get the tmdb id
movie.GetSourceMovieInfo(SourceInfo).Identifier = movieDetails.Id.ToString();
// get the localised title if available otherwise fallback to original title
movie.Title = string.IsNullOrEmpty(movieDetails.Title) ? movieDetails.OriginalTitle : movieDetails.Title;
// get alternative titles
var altTitles = TheMovieDbAPI.GetAlternativeTitles(movieDetails.Id.ToString());
if (altTitles != null && altTitles.Titles != null)
{
movie.AlternateTitles.AddRange(altTitles.Titles.Select(a => a.Title));
}
// get languages
if (movieDetails.SpokenLanguages != null)
{
movie.Language = string.Join("|", movieDetails.SpokenLanguages.Select(l => l.Name).ToArray());
}
// get tagline
movie.Tagline = movieDetails.Tagline;
// get imdb id
movie.ImdbID = movieDetails.ImdbId;
// get homepage
movie.DetailsURL = movieDetails.HomePage;
// get movie overview
movie.Summary = movieDetails.Overview;
// get movie score
movie.Score = movieDetails.Score;
// get movie vote count
movie.Popularity = movieDetails.Votes;
// get runtime (mins)
movie.Runtime = movieDetails.Runtime == null ? 0 : (int)movieDetails.Runtime;
// get movie cast
var castInfo = TheMovieDbAPI.GetCastInfo(movieDetails.Id.ToString());
if (castInfo != null)
{
// add actors, sort by order field
if (castInfo.Cast != null)
{
movie.Actors.AddRange(castInfo.Cast.OrderBy(a => a.Order).Select(a => a.Name));
}
// add directors
if (castInfo.Crew != null)
{
movie.Directors.AddRange(castInfo.Crew.Where(c => c.Department == "Directing").Select(c => c.Name).Distinct());
}
// add writers
if (castInfo.Crew != null)
{
movie.Writers.AddRange(castInfo.Crew.Where(c => c.Department == "Writing").Select(c => c.Name).Distinct());
}
}
// add genres
if (movieDetails.Genres != null)
{
movie.Genres.AddRange(movieDetails.Genres.Select(g => g.Name).ToArray());
}
// add collection - only one supported by TMDb
if (movieDetails.BelongsToCollection != null)
{
// remove 'Collection' from name
string collection = movieDetails.BelongsToCollection.Name.Replace("Collection", "").Trim();
movie.Collections.Add(collection);
}
// add production companies (studios)
if (movieDetails.ProductionCompanies != null)
{
movie.Studios.AddRange(movieDetails.ProductionCompanies.Select(p => p.Name));
}
// add release date and year
DateTime date;
if (DateTime.TryParse(movieDetails.ReleaseDate, out date))
{
movie.Year = date.Year;
movie.ReleaseDate = date;
}
// add certification (US MPAA rating)
var movieCertifications = TheMovieDbAPI.GetReleaseInfo(movieDetails.Id.ToString());
if (movieCertifications != null && movieCertifications.Countries != null)
{
// this could also be a scraper setting to get certification and release date from preferred country
var releaseInfo = movieCertifications.Countries.Find(c => c.CountryCode == "US");
if (releaseInfo != null)
{
movie.Certification = releaseInfo.Certification;
// todo: uncomment this later if we have a setting for preferred country, it will override the release date that was previously set
//if (DateTime.TryParse(releaseInfo.ReleaseDate, out date))
//{
// movie.ReleaseDate = date;
//}
}
}
// get plot keywords
var plotKeywords = TheMovieDbAPI.GetPlotKeywords(movieDetails.Id.ToString());
if (plotKeywords != null)
{
movie.PlotKeywords.AddRange(plotKeywords.Keywords.Select(k => k.Name).ToArray());
}
return(movie);
}
public bool GetBackdrop(DBMovieInfo movie)
{
if (movie == null)
{
return(false);
}
// if we already have a backdrop move on for now
if (movie.BackdropFullPath.Trim().Length > 0)
{
return(true);
}
// do we have an id?
string movieId = getMovieId(movie);
if (string.IsNullOrEmpty(movieId))
{
return(false);
}
string url = apiMovieArtwork;
if (!string.IsNullOrWhiteSpace(MovingPicturesCore.Settings.FanartTVClientKey))
{
url = url + "&client_key=" + MovingPicturesCore.Settings.FanartTVClientKey;
}
string response = getJson(string.Format(url, movieId));
if (response == null)
{
return(false);
}
// de-serialize json response
var movieImages = response.FromJson <Artwork>();
if (movieImages == null)
{
return(false);
}
// check if we have any backdrops
if (movieImages.moviebackground == null || movieImages.moviebackground.Count == 0)
{
return(false);
}
// get the 1st (highest rated) movie backdrop
// only single backdrops are currently supported
string backdropUrl = movieImages.moviebackground.First().url;
if (backdropUrl.Trim().Length > 0)
{
if (movie.AddBackdropFromURL(backdropUrl) == ImageLoadResults.SUCCESS)
{
// store either the imdb id or tmdb id of movie for identifier
// there is no per movie id from fanart.tv, only per image id
movie.GetSourceMovieInfo(SourceInfo).Identifier = movieId;
return(true);
}
}
// if we get here we didn't manage to find a proper backdrop
return(false);
}
public bool GetBackdrop(DBMovieInfo movie)
{
if (movie == null)
{
return(false);
}
// if we already have a backdrop move on for now
if (movie.BackdropFullPath.Trim().Length > 0)
{
return(true);
}
// do we have an id?
string tmdbID = getTheMovieDbId(movie, true);
if (tmdbID == null)
{
return(false);
}
// try to get movie artwork
var movieArtwork = TheMovieDbAPI.GetMovieImages(tmdbID);
if (movieArtwork == null || movieArtwork.Backdrops == null || movieArtwork.Backdrops.Count == 0)
{
return(false);
}
// filter out minimum size images
int minWidth = MovingPicturesCore.Settings.MinimumBackdropWidth;
int minHeight = MovingPicturesCore.Settings.MinimumBackdropHeight;
movieArtwork.Backdrops.RemoveAll(b => b.Width < minWidth || b.Height < minHeight);
if (movieArtwork.Backdrops.Count == 0)
{
return(false);
}
// sort by highest rated / most popular
var backdrops = movieArtwork.Backdrops.OrderByDescending(p => p.Score);
// get the base url for images
string baseImageUrl = getImageBaseUrl();
if (string.IsNullOrEmpty(baseImageUrl))
{
return(false);
}
// moving pics currently only supports 1 backdrop per movie
string backdropURL = baseImageUrl + backdrops.First().FilePath;
if (backdropURL.Trim().Length > 0)
{
if (movie.AddBackdropFromURL(backdropURL) == ImageLoadResults.SUCCESS)
{
movie.GetSourceMovieInfo(SourceInfo).Identifier = tmdbID;
return(true);
}
}
// if we get here we didn't manage to find a proper backdrop
// so return false
return(false);
}
public bool GetBackdrop(DBMovieInfo movie)
{
throw new NotImplementedException();
}
/// <summary>
/// Get a MovingPictures movie id that matches a movie
/// for the supplied file name
/// </summary>
/// <param name="movieName">A movie name</param>
/// <returns>A movie id or -1 if no movie was found</returns>
public static int GetMovieIdByName(string movieName)
{
DBMovieInfo movie = GetMovieByName(movieName);
return((movie != null && movie.ID != null) ? (int)movie.ID : -1);
}
private void RebuildRenamableList()
{
DBMovieInfo currMovie = movieEnumerator.Current;
itemsToRename = movieRenamer.GetRenameActionList(currMovie);
}
private static string DetermineGroupName(DBMovieInfo movie)
{
switch (Browser.CurrentSortField)
{
case SortingFields.Title:
// Either the first character of the title, or the word "Numeric"
// should we have a category for special characters like numeric has?
string groupName = "";
if (movie.SortBy.Trim().Length > 0)
{
groupName = movie.SortBy.Trim().Substring(0, 1).ToUpper();
}
// group all non-word characters together
if (!Regex.Match(groupName, @"\w").Success)
{
groupName = "#";
}
// numeric group
int iTemp;
if (int.TryParse(groupName, out iTemp))
{
groupName = "0-9";
}
return(groupName);
case SortingFields.DateAdded:
return(GetDateGroupName(movie.DateAdded.Date));
case SortingFields.ReleaseDate:
return(Translation.GetByName("MonthName" + movie.ReleaseDate.Month.ToString()) + ", " + movie.ReleaseDate.Year.ToString());
case SortingFields.Year:
return(movie.Year.ToString());
case SortingFields.Certification:
return(movie.Certification.Trim().ToUpper());
case SortingFields.Language:
return(movie.Language.Trim().ToUpper());
case SortingFields.Score:
return(Math.Round(movie.Score).ToString());
case SortingFields.Runtime:
return("");
case SortingFields.FileSize:
string size = movie.LocalMedia[0].FileSize.ToFormattedByteString();
// split the string to get size and unit
string[] splits = size.Split(' ');
// round the size to the nearest unit
int roundedSize = (int)Math.Round(double.Parse(splits[0]), MidpointRounding.ToEven);
// group by rounded size
return(roundedSize.ToString() + " " + splits[1]);
case SortingFields.FilePath:
if (movie.LocalMedia.Count > 0)
{
return(movie.LocalMedia[0].File.Directory.ToString());
}
else
{
return("");
}
default:
return("");
}
}
