protected void LogIntoDB(string SearchFor, MovieSearchResult result)
{
var search = DBSRLOG.AddEditSearch(
new Entities.Search
{
SearchFor = SearchFor,
Response = result.Response,
TotalRecords = result.TotalResults
});
if (search != null && result.Search.Count > 0)
{
if (search.Id > 0)
{
foreach (var item in result.Search)
{
DBSRLOG.AddEditSearchResult(
new Entities.SearchResult {
Search = search, imdbID = item.imdbID, Poster = item.Poster, Title = item.Title, Type = item.Type, Year = item.Year
}
);
}
}
}
}
void AddMovieExecute(MovieSearchResult movieSearchResult)
{
if (!movieSearchResult.IsValid())
{
Dialog.ShowMessage(String.Format("Movie is invalid. Errors {0}", movieSearchResult.Error), "Invalid Data", DialogButton.OK, DialogImage.Exclamation);
return;
}
Movie movie = new Movie(
movieSearchResult.Name,
movieSearchResult.Description,
movieSearchResult.ImageURL,
movieSearchResult.Image,
movieSearchResult.Paid,
movieSearchResult.Id,
movieSearchResult.PurchasedFrom,
movieSearchResult.Cast,
movieSearchResult.PublicRating,
movieSearchResult.YearReleased,
movieSearchResult.MediaType,
movieSearchResult.MyRating);
MovieDataStoreService.Items.Add(movie);
movieSearchResult.InLocalDatabase = true;
MovieDataStoreService.Save();
}
private async void button1_Click(object sender, EventArgs e)
{
// Written, 14.09.2020
this.searchResults = await MovieSearchResult.searchAsync(this.textBox1.Text, 1);
this.populateListBoxWithMovieSearchResults(this.searchResults);
}
static void Main(string[] args)
{
// Written, 01.01.2020
Console.WriteLine("Testing PageResult\nMovie Search Result Test:");
PageResult <MovieSearchResult> moviePageResult = new PageResult <MovieSearchResult>(null)
{
searchPhrase = "the simpsons",
methodName = "searchAsync",
};
Task task = moviePageResult.nextPage();
task.Wait();
for (int i = 0; i < moviePageResult.results.Length; i++)
{
Console.WriteLine("{0}.) {1}", i + 1, moviePageResult.results[i].name);
}
Console.WriteLine("Multi Search Result Test:");
PageResult <MultiSearchResult> multiPageResult = new PageResult <MultiSearchResult>(new MultiSearchResult())
{
searchPhrase = "the simpsons",
methodName = "searchAsync"
};
Task task1 = multiPageResult.nextPage();
task1.Wait();
int totalResults = 0;
for (int i = 0; i < ApplicationInfomation.NUMBER_OF_ITEMS_PER_PAGE; i++)
{
MovieSearchResult movie = multiPageResult.accumulator.movies[i];
if (movie != null)
{
Console.WriteLine("\t[MOVIE] {0} ({1})", movie.name, movie.release_date);
totalResults++;
}
else
{
TvSearchResult tvSeries = multiPageResult.accumulator.tvSeries[i];
if (tvSeries != null)
{
Console.WriteLine("\t[TV] {0} ({1})", tvSeries.name, tvSeries.release_date);
totalResults++;
}
else
{
PeopleSearchResult person = multiPageResult.accumulator.people[i];
if (person != null)
{
Console.WriteLine("\t[PERSON] {0} ({1})", person.id, person.profile_path);
totalResults++;
}
}
}
}
Console.WriteLine("Total Results: {0}", totalResults);
Console.ReadKey();
}
/// <summary>
/// Creates a movie search result model from an external movie search result.
/// </summary>
/// <param name="source">The external movie search result.</param>
/// <returns>Movie search result model</returns>
public MovieSearchResultModel Create(MovieSearchResult source)
{
return(new MovieSearchResultModel
{
TotalPages = source.TotalPages,
TotalResults = source.TotalResults,
Results = source.Results.Select(x => Create(x)).ToList()
});
}
/// <summary>
/// Returns the Levenshtein distance for a <see cref="MovieSearchResult"/> and a given <paramref name="movieName"/>.
/// It considers both <see cref="MovieSearchResult.Title"/> and <see cref="MovieSearchResult.OriginalTitle"/>
/// </summary>
/// <param name="movie">MovieSearchResult</param>
/// <param name="movieName">Movie name</param>
/// <returns>Levenshtein distance</returns>
protected int GetLevenshteinDistance(MovieSearchResult movie, string movieName)
{
string cleanedName = RemoveCharacters(movieName);
return(Math.Min(
StringUtils.GetLevenshteinDistance(RemoveCharacters(movie.Title), cleanedName),
StringUtils.GetLevenshteinDistance(RemoveCharacters(movie.OriginalTitle), cleanedName)
));
}
public void FindMoviesAsync(string query, int pageSize) {
MovieSearchResult ms = new MovieSearchResult();
EventHandler<EventArgs> f = null;
f = (s, ea) => {
ms.FindMoviesCompleted -= f;
OnFindMoviesCompleted(ms);
};
ms.FindMoviesCompleted += f;
ms.FindMoviesAsync(query, pageSize);
}
/// <summary>
/// Method to search for the movies with the entered text
/// </summary>
/// <param name="searchText">Entered search text</param>
/// <returns>Partial view with the list of top 20 movies</returns>
public async Task <ActionResult> SearchMovie(string searchText)
{
List <Movie> movieInfo = new List <Movie>();
//Hosted web API REST Service base url
string baseurl = Convert.ToString(ConfigurationManager.AppSettings["BASEURL"]);
string apiKey = Convert.ToString(ConfigurationManager.AppSettings["TMDBAPIKEY"]);
string posterBaseUrl = Convert.ToString(ConfigurationManager.AppSettings["POSTERBASEURL"]);
try
{
using (var client = new HttpClient())
{
//Passing service base url
client.BaseAddress = new Uri(baseurl);
client.DefaultRequestHeaders.Clear();
//Define request data format
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
//Sending request to find web api REST service resource using HttpClient
//per page it returns max 20 rows by default, so taking only the first page
//so that we get top 20 as a result.
HttpResponseMessage res = await client.GetAsync("search/movie?api_key=" + apiKey + "&page=1&query=" + searchText);
//Checking the response is successful or not which is sent using HttpClient
if (res.IsSuccessStatusCode)
{
//Storing the response details recieved from web api
var movieResponse = res.Content.ReadAsStringAsync().Result;
//Deserializing the response recieved from web api and storing into the Movie list
MovieSearchResult movieSearchResult = JsonConvert.DeserializeObject <MovieSearchResult>(movieResponse);
movieInfo = (from mv in movieSearchResult.results.ToList()
select new Movie
{
Id = mv.id,
Title = mv.title,
AverageVote = mv.vote_average,
Overview = mv.overview,
PosterPath = posterBaseUrl + mv.poster_path,
ReleaseDate = mv.release_date
}).ToList();
}
//returning the partial view with movie list
return(PartialView("_Movie", movieInfo));
}
}
catch (Exception)
{
return(null);
}
}
public MovieTag UpdateTags(MovieTag movieTag)
{
if (movieDbApi == null)
{
movieDbApi = new MovieDbApiV3(API_KEY, null);
}
Movie movie;
string imdb = movieTag.IMDB_ID;
if (!string.IsNullOrEmpty(imdb))
{
movie = movieDbApi.GetMovie(imdb, App.Config.SelectedTMDBLanguageValue);
if (movie != null)
{
return(CopyMovieInfos(movieTag, movie));
}
MessageBox.Show("TMDB lookup by IMDB id failed.");
}
string name = movieTag.Title;
if (string.IsNullOrEmpty(imdb) && string.IsNullOrEmpty(name))
{
MessageBox.Show("TMDB lookup needs atleast IMDB id or movie title.");
return(movieTag);
}
MovieSearchResult searchResult = SearchMovie(name);
if (searchResult == null)
{
return(movieTag);
}
movie = movieDbApi.GetMovie(searchResult.Id, App.Config.SelectedTMDBLanguageValue);
if (movie == null)
{
return(movieTag);
}
return(CopyMovieInfos(movieTag, movie));
}
// GET: Home/Search/
public ActionResult Search(string textToSearch, int?page)
{
if (textToSearch == "")
{
return(RedirectToAction("Index"));
}
ViewBag.Message = "Search result";
TMDbClient client = new TMDbClient(ApiKey);
int pageNumber = (page ?? 1);
List <SearchMovie> searchMovies = client.SearchMovie(textToSearch, pageNumber).Results;
MovieSearchResult moviesSearchResult = new MovieSearchResult();
moviesSearchResult.textToSearch = textToSearch;
moviesSearchResult.movieSearchResult = searchMovies;
moviesSearchResult.totalPages = client.SearchMovie(textToSearch).TotalPages;
return(View("SearchResult", moviesSearchResult));
}
private async Task updateYtsMediaActionsAsync()
{
// Written, 21.09.2020
if (this.ytsMovieResults_listView.SelectedItems.Count == 1)
{
MovieSearchResult media = this.ytsMovieResults_listView.SelectedItems[0].Tag as MovieSearchResult;
if (media != null)
{
this.yts_selectedMedia = media;
this.actions_groupBox.Text = "Actions: " + media.name;
this.mediaPoster_pictureBox.Image = media.poster_image;
this.yts_button.Enabled = true;
this.yts_button.Text = "Search YTS";
await this.updateMediaPosterAsync(this.ytsMovieResults_listView, media, YTSManager.YTS_ADDRESS);
}
}
else
{
this.actions_groupBox.Text = "Actions";
this.yts_button.Enabled = false;
this.mediaPoster_pictureBox.Image = null;
}
}
private async Task <SearchMovieViewModel> ProcessSingleMovie(MovieSearchResult movie)
{
var viewMovie = Mapper.Map <SearchMovieViewModel>(movie);
return(await ProcessSingleMovie(viewMovie));
}
public void setCurrentSearchResults(MovieSearchResult msr)
{
currentSearch = msr;
}
// Written, 24.11.2019
static async Task Main(string[] args)
{
// Written, 25.11.2019
Console.WriteLine("The Library v1.1 Search Test\nEnter Phrase and press Enter to search for movies and tv series individually ");
string searchPhrase = Console.ReadLine();
bool searchOK = true;
MovieSearchResult[] movieSearchResults = null;
Console.WriteLine("\n\nMovie Search Function\n-------------------------------------------");
try
{
movieSearchResults = await MovieSearchResult.searchAsync(searchPhrase, 1);
for (int i = 0; i < movieSearchResults.GetLength(0); i++)
{
Console.WriteLine("{0}.) {1}", i + 1, movieSearchResults[i].name);
}
Console.WriteLine("Total Results: " + movieSearchResults.GetLength(0));
}
catch
{
searchOK = false;
}
TvSearchResult[] tvSearchResults = null;
Console.WriteLine("\n\nTv Search Function\n----------------------------------------------");
try
{
tvSearchResults = await TvSearchResult.searchAsync(searchPhrase, 1);
for (int i = 0; i < tvSearchResults.GetLength(0); i++)
{
Console.WriteLine("{0}.) {1}", i + movieSearchResults.GetLength(0) + 1, tvSearchResults[i].name);
}
Console.WriteLine("Total Results: " + tvSearchResults.GetLength(0));
}
catch
{
searchOK = false;
}
if (searchOK)
{
if (movieSearchResults.GetLength(0) + tvSearchResults.GetLength(0) > 0)
{
Console.WriteLine("Enter movie or tv series number to retrieve details.");
if (Int32.TryParse(Console.ReadLine(), out int searchNum))
{
try
{
MediaSearchResult result = null;
if (searchNum <= movieSearchResults.GetLength(0))
{
result = movieSearchResults[searchNum - 1];
}
else
{
int tvSearchNum = searchNum - movieSearchResults.GetLength(0);
if (tvSearchNum <= tvSearchResults.GetLength(0))
{
result = tvSearchResults[tvSearchNum - 1];
}
else
{
throw new NullReferenceException("result is null.");
}
}
if (result is TvSearchResult)
{
Console.WriteLine("[TV] Selected, {0}\nRetrieving tv series details for ID: {1}..", (result as TvSearchResult).name, result.id);
TvSeriesResult tvResult = await TvSeriesResult.retrieveDetailsAsync(result.id);
Console.WriteLine("\nDETAILS RETRIEVED:\nName: {0}\nFirst Aired: {1}\nOverview: {2}\nRating: {3}\nSeasons #: {4}\nEpisodes #: {5}\nAvg ep runtime: {6}minutes\nType: {7}\nStatus: {8}",
tvResult.name, tvResult.release_date, tvResult.overview, tvResult.vote_average, tvResult.number_of_seasons, tvResult.number_of_episodes, tvResult.episode_run_time[0], tvResult.type, tvResult.status);
}
else
{
if (result is MovieSearchResult)
{
Console.WriteLine("[MOVIE] Selected, {0}\nRetrieving movie details for ID: {1}..", (result as MovieSearchResult).name, result.id);
MovieResult movieResult = await MovieResult.retrieveDetailsAsync(result.id);
Console.WriteLine("\nDETAILS RETRIEVED:\nName: {0}\nRelease Date: {1}\nOverview: {2}\nRating: {3}",
movieResult.name, movieResult.release_date, movieResult.overview, movieResult.vote_average);
}
}
}
catch (NullReferenceException)
{
Console.WriteLine("Error: NullReferenceException. Probably number out of range.");
}
}
else
{
Console.WriteLine("\nError: number expected");
}
}
else
{
Console.WriteLine("\nNo results found");
}
}
Console.WriteLine("\n\nPress R to restart or press any key to exit");
if (Console.ReadKey().Key == ConsoleKey.R)
{
Console.Clear();
await Main(null);
}
}
static async Task Main(string[] args)
{
// Written, 01.12.2019
Console.WriteLine("The Library v1.1 Review Test\nEnter Phrase and press Enter to search for movie & tv series reviews");
string searchPhrase = Console.ReadLine();
bool searchOK = true;
MovieSearchResult[] movieSearchResults = null;
Console.WriteLine("\n\nMovie Search Function\n-------------------------------------------");
try
{
movieSearchResults = await MovieSearchResult.searchAsync(searchPhrase, 1);
for (int i = 0; i < movieSearchResults.GetLength(0); i++)
{
Console.WriteLine("{0}.) {1}", i + 1, movieSearchResults[i].name);
}
Console.WriteLine("Total Results: " + movieSearchResults.GetLength(0));
}
catch
{
searchOK = false;
}
TvSearchResult[] tvSearchResults = null;
Console.WriteLine("\n\nTv Search Function\n----------------------------------------------");
try
{
tvSearchResults = await TvSearchResult.searchAsync(searchPhrase, 1);
for (int i = 0; i < tvSearchResults.GetLength(0); i++)
{
Console.WriteLine("{0}.) {1}", i + movieSearchResults.GetLength(0) + 1, tvSearchResults[i].name);
}
Console.WriteLine("Total Results: " + tvSearchResults.GetLength(0));
}
catch
{
searchOK = false;
}
if (searchOK)
{
if (movieSearchResults.GetLength(0) + tvSearchResults.GetLength(0) > 0)
{
Console.WriteLine("Enter movie or tv series number to retrieve details.");
if (Int32.TryParse(Console.ReadLine(), out int searchNum))
{
try
{
MediaSearchResult result = null;
if (searchNum <= movieSearchResults.GetLength(0))
{
result = movieSearchResults[searchNum - 1];
}
else
{
int tvSearchNum = searchNum - movieSearchResults.GetLength(0);
if (tvSearchNum <= tvSearchResults.GetLength(0))
{
result = tvSearchResults[tvSearchNum - 1];
}
else
{
throw new NullReferenceException("result is null.");
}
}
if (result is MovieSearchResult)
{
Console.WriteLine("[MOVIE] Selected, {0}\nRetrieving movie reviews for ID: {1}..", result.name, result.id);
await(result as MovieSearchResult).retrieveReviewsAsync();
}
else
{
if (result is TvSearchResult)
{
Console.WriteLine("[TV] Selected, {0}\nRetrieving tv series reviews for ID: {1}..", result.name, result.id);
await(result as TvSeriesResult).retrieveReviewsAsync();
}
}
if (result.reviews.GetLength(0) < 1)
{
Console.WriteLine("\nNo reviews recorded");
}
else
{
for (int i = 0; i < result.reviews.GetLength(0); i++)
{
Review review = result.reviews[i];
Console.WriteLine("\n{0}.) {1} by {2}\n{3}\n...See [{4}]", i + 1, review.reviewID, review.author, review.content, review.url);
}
}
}
catch (NullReferenceException)
{
Console.WriteLine("Error: NullReferenceException. Probably number out of range.");
}
}
else
{
Console.WriteLine("\nError: number expected");
}
}
else
{
Console.WriteLine("\nNo results found");
}
}
Console.WriteLine("\n\nPress R to restart or press any key to exit");
if (Console.ReadKey().Key == ConsoleKey.R)
{
Console.Clear();
await Main(null);
}
}
private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
this.selectedResult = this.searchResults[this.listBox1.SelectedIndex];
}
public static MovieSearch ToModel(this MovieSearchResult movie)
{
return(new MovieSearch(movie.Id, movie.Title, movie.ImagePath, SharedFunctions.GetCultureDate(movie.ReleaseDate)));
}
protected virtual void OnFindMoviesCompleted(MovieSearchResult ms) {
if (FindMoviesCompleted != null)
FindMoviesCompleted(this, new ResultEventArgs<MovieSearchResult>(ms));
}
static async Task Main(string[] args)
{
// Written, 29.11.2019
Console.WriteLine("The Library v1.1 Multi-Search Test\nEnter Phrase and press Enter to search for movies, tv series and people as a multi-search request.");
string searchPhrase = Console.ReadLine();
MultiSearchResult multiSearch = null;
Console.WriteLine("\n\nMulti-Search Function\n-------------------------------------------");
try
{
multiSearch = await MultiSearchResult.searchAsync(searchPhrase, 1);
}
catch (AggregateException ex)
{
string exMessage = ex.Message;
for (int i = 0; i < ex.InnerExceptions.Count; i++)
{
exMessage += String.Format("\n{0}.) {1}", i + 1, ex.InnerExceptions[i].Message);
}
Console.WriteLine("An error occured while performing multi-search function: {0}", exMessage);
}
int totalResults = 0;
for (int i = 0; i < ApplicationInfomation.NUMBER_OF_ITEMS_PER_PAGE; i++)
{
MovieSearchResult movie = multiSearch.movies[i];
if (movie != null)
{
Console.WriteLine("\t[MOVIE] {0} ({1})", movie.name, movie.release_date);
totalResults++;
}
else
{
TvSearchResult tvSeries = multiSearch.tvSeries[i];
if (tvSeries != null)
{
Console.WriteLine("\t[TV] {0} ({1})", tvSeries.name, tvSeries.release_date);
totalResults++;
}
else
{
PeopleSearchResult person = multiSearch.people[i];
if (person != null)
{
Console.WriteLine("\t[PERSON] {0} ({1})", person.id, person.profile_path);
totalResults++;
}
}
}
}
Console.WriteLine("Total Results: {0}", totalResults);
Console.WriteLine("\n\nPress R to restart or press any key to exit");
if (Console.ReadKey().Key == ConsoleKey.R)
{
Console.Clear();
await Main(null);
}
}
//Builds the search results used by the front end using a MovieSearchResult object
public void buildMovieList(int resultCount, List <Movie> searchResults, string filter)
{
currentSearch = new MovieSearchResult(resultCount, searchResults, filter);
}
protected bool TryMatch(string movieName, int year, string language, bool cacheOnly, out Movie movieDetail)
{
movieDetail = null;
try
{
// Prefer memory cache
CheckCacheAndRefresh();
if (_memoryCache.TryGetValue(movieName, out movieDetail))
{
return(true);
}
// Load cache or create new list
List <MovieMatch> matches = _storage.GetMatches();
// Init empty
movieDetail = null;
// Use cached values before doing online query
MovieMatch match = matches.Find(m =>
string.Equals(m.ItemName, movieName, StringComparison.OrdinalIgnoreCase) ||
string.Equals(m.MovieDBName, movieName, StringComparison.OrdinalIgnoreCase));
ServiceRegistration.Get <ILogger>().Debug("MovieTheMovieDbMatcher: Try to lookup movie \"{0}\" from cache: {1}", movieName, match != null && match.Id != 0);
// Try online lookup
if (!Init())
{
return(false);
}
// If this is a known movie, only return the movie details.
if (match != null)
{
return(match.Id != 0 && _movieDb.GetMovie(match.Id, out movieDetail));
}
if (cacheOnly)
{
return(false);
}
List <MovieSearchResult> movies;
if (_movieDb.SearchMovieUnique(movieName, year, language, out movies))
{
MovieSearchResult movieResult = movies[0];
ServiceRegistration.Get <ILogger>().Debug("MovieTheMovieDbMatcher: Found unique online match for \"{0}\": \"{1}\"", movieName, movieResult.Title);
if (_movieDb.GetMovie(movies[0].Id, out movieDetail))
{
// Add this match to cache
MovieMatch onlineMatch = new MovieMatch
{
Id = movieDetail.Id,
ItemName = movieName,
MovieDBName = movieDetail.Title
};
// Save collection mapping, if available
if (movieDetail.Collection != null)
{
MovieCollectionMatch collectionMatch = new MovieCollectionMatch
{
Id = movieDetail.Collection.Id,
ItemName = movieDetail.Collection.Name
};
_collectionStorage.TryAddMatch(collectionMatch);
}
// Save cache
_storage.TryAddMatch(onlineMatch);
}
return(true);
}
ServiceRegistration.Get <ILogger>().Debug("MovieTheMovieDbMatcher: No unique match found for \"{0}\"", movieName);
// Also save "non matches" to avoid retrying
_storage.TryAddMatch(new MovieMatch {
ItemName = movieName
});
return(false);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Debug("MovieTheMovieDbMatcher: Exception while processing movie {0}", ex, movieName);
return(false);
}
finally
{
if (movieDetail != null)
{
_memoryCache.TryAdd(movieName, movieDetail);
}
}
}
public IEnumerable<MovieSearchResult> SearchMovies(string title, Nullable<int> year)
{
// Query TMDb for movies with the given title and year.
string fetchUrl = TMDB_COMMAND_URL;
fetchUrl = fetchUrl.Replace("{cmd}", "Movie.search");
fetchUrl = fetchUrl.Replace("{lang}", m_language);
fetchUrl = fetchUrl.Replace("{key}", m_apiKey);
if (year != null)
fetchUrl = fetchUrl + title + "+" + year.ToString();
else
fetchUrl = fetchUrl + title;
XDocument searchPage = XDocument.Load(fetchUrl);
List<MovieSearchResult> results = new List<MovieSearchResult>();
foreach (XElement x in searchPage.Root.Elements("movies").Descendants("movie"))
{
MovieSearchResult result = new MovieSearchResult();
result.ID = x.Element("id").Value;
result.Title = x.Element("name").Value;
result.Released = null;
string released = x.Element("released").Value;
if (!string.IsNullOrEmpty(released))
result.Released = DateTime.Parse(released);
results.Add(result);
}
return results;
}
