/// <summary>
/// Does the response initialization for incoming GET requests
/// </summary>
public void OnGet(double?IMDBMin, double?IMDBMax)
{
/*
* // Nullable conversion workaround
* this.IMDBMin = IMDBMin;
* this.IMDBMax = IMDBMax;
* MPAARating = Request.Query["MPAARatings"];
* Genres = Request.Query["Genres"];
* Movies = MovieDatabase.Search(SearchTerms);
* Movies = MovieDatabase.FilterByMPAARating(Movies, MPAARating);
* Movies = MovieDatabase.FilterByGenre(Movies, Genres);
* Movies = MovieDatabase.FilterByIMDBRating(Movies, IMDBMin, IMDBMax);
*/
Movies = MovieDatabase.All;
// Search movie titles for the SearchTerms
if (SearchTerms != null)
{
Movies = Movies.Where(movie => movie.Title != null && movie.Title.Contains(SearchTerms, StringComparison.InvariantCultureIgnoreCase));
}
// Filter by MPAA Rating
if (MPAARating != null && MPAARating.Length != 0)
{
Movies = Movies.Where(movie =>
movie.MPAARating != null &&
MPAARating.Contains(movie.MPAARating)
);
}
}
private MediaType _medium; // The movie's medium
public LibraryMovie(string theTitle, string thePublisher, int theCopyrightYear, int theLoanPeriod,
string theCallNumber, double theDuration, string theDirector, MediaType theMedium, MPAARating theRating)
: base(theTitle, thePublisher, theCopyrightYear, theLoanPeriod, theCallNumber, theDuration)
{
Director = theDirector;
Medium = theMedium;
Rating = theRating;
}
public Movie(String name, DateTime releaseDate, MPAARating ageRating, double basePrice)
{
this.name = name;
this.releaseDate = releaseDate;
this.totalNoOfPurchases = 0;
this.ageRating = ageRating;
this.basePrice = basePrice;
}
private MPAARating _rating; //The movie's rating
#endregion Fields
#region Constructors
// Precondition: None
// Postcondition: The library periodical has been initialized with the specified
// values for title, publisher, copyright year, loan period, call number,
// duration, director, medium, and rating. The book is not checked out.
public LibraryMovie(string title, string publisher, int copyrightYear, int loanPeriod,
string callNumber, double duration, string director, MediaType medium, MPAARating rating)
: base(title, publisher, copyrightYear, loanPeriod, callNumber, duration)
{
Director = director;
Medium = medium;
Rating = rating;
}
public override int GetHashCode()
{
int result = 0;
if (Title != null)
{
result ^= Title.GetHashCode();
}
result ^= Duration.GetHashCode();
if (MPAARating != null)
{
result ^= MPAARating.GetHashCode();
}
result ^= ReleaseDate.ToUniversalTime().GetHashCode();
result ^= BestPictureWinner.GetHashCode();
result ^= Year.GetHashCode();
return(result);
}
public SelectList GetAllMPAARatings()
{
List <MPAARating> MPAARatings = new List <MPAARating>();
MPAARating SelectNone = MPAARating.None; // TODO: need to check that this is a valid way to make selectnone
MPAARatings.Add(SelectNone);
foreach (Movie m in db.Movies.ToList())
{
if (!MPAARatings.Contains(m.MPAARating))
{
MPAARatings.Add(m.MPAARating);
}
}
SelectList AllRatings = new SelectList(MPAARatings);
return(AllRatings);
}
//LINQ Comprehension Syntax
//var evenNums = from int num in nums
// where num % 2 == 0
// select num;
//LINQ Extension Syntax
//var evenNums = nums.Where(num => num % 2 = 0);
//Where, Select, Orderby, OrderByDescending, GroupBy, Min, Max
//LINQ Desugarized Syntax
//var evenNums = Enumerable.Where(nums, Predicate1);
static void Main(string[] args)
{
//Oldest and Newest Movies
var NewMovie = from Movie in MovieLoader.AllMovies
orderby Movie.Year descending
select Movie;
Console.WriteLine("Newest Movie: ");
foreach (var Movie in NewMovie.Take(1))
{
Console.WriteLine($"{Movie.Title,-20} : {Movie.Year,10}");
}
var OldMovie = from Movie in MovieLoader.AllMovies
orderby Movie.Year ascending
select Movie;
Console.WriteLine("Oldest Movie: ");
foreach (var Movie in OldMovie.Take(1))
{
Console.WriteLine($"{Movie.Title,-20} : {Movie.Year,10}");
}
Console.WriteLine("************************************************");
//Find Classic and New, based on range of year split
int avg = 0;
int totYear = 0;
foreach (var Movie in MovieLoader.AllMovies)
{
totYear += Movie.Year;
}
avg = totYear / MovieLoader.AllMovies.Count();
var Classic = from Movie in MovieLoader.AllMovies
orderby Movie.Year descending
where Movie.Year < avg
select Movie;
Console.WriteLine("All the Classics: ");
foreach (var Movie in Classic)
{
Console.WriteLine($"{Movie.Title,-20} : {Movie.Year,10}");
}
Console.WriteLine($"Total Classics: {Classic.Count()}");
var Newbies = from Movie in MovieLoader.AllMovies
orderby Movie.Year descending
where Movie.Year >= avg
select Movie;
Console.WriteLine("All the Newbies: ");
foreach (var Movie in Newbies)
{
Console.WriteLine($"{Movie.Title,-20} : {Movie.Year,10}");
}
Console.WriteLine($"Total Newbies: {Newbies.Count()}");
Console.WriteLine("************************************************");
//More Odd Years or even Years? Answer and Print Totals
var Evens = from Movie in MovieLoader.AllMovies
where Movie.Year % 2 == 0
select Movie;
var Odds = from Movie in MovieLoader.AllMovies
where Movie.Year % 2 != 0
select Movie;
Console.WriteLine($"Total Number of Even-Yeared Movies: {Evens.Count()}");
Console.WriteLine($"Total Number of Odd-Yeared Movies: {Odds.Count()}");
Console.WriteLine("************************************************");
//Most Common Year, Qty
var PopYear = from Movie in MovieLoader.AllMovies
group Movie by Movie.Year into g
orderby g.Count() descending
select g;
/*
* foreach (var MovieGroup in PopYear)
* {
* Console.WriteLine(MovieGroup.Key);
* foreach (var Movie in MovieGroup)
* {
* Console.WriteLine(Movie.Title, Movie.Year);
* Console.WriteLine("");
* }
* }
*/
Console.WriteLine("Most Movies: ");
foreach (var Movie in PopYear.Take(1))
{
Console.WriteLine($"Year: {Movie.Key}, Number of Movies: {Movie.Count()}");
}
Console.WriteLine("************************************************");
//Most Common Rating, Qty
var PopRating = from Movie in MovieLoader.AllMovies
group Movie by Movie.Rating into g
orderby g.Count() descending
select g;
/*
* foreach (var MovieGroup in PopRating)
* {
* Console.WriteLine(MovieGroup.Key);
* foreach (var Movie in MovieGroup)
* {
* Console.WriteLine(Movie.Title, Movie.Rating);
* Console.WriteLine("");
* }
* }
*/
Console.WriteLine("Most Movies per Rating: ");
foreach (var Movie in PopRating.Take(1))
{
Console.WriteLine($"Rating: {Movie.Key}, Number of Movies: {Movie.Count()}");
}
Console.WriteLine("************************************************");
//Shortest Title, Longest Title
var ShortTitle = from Movie in MovieLoader.AllMovies
orderby Movie.Title.Length ascending
select Movie;
foreach (var Movie in ShortTitle.Take(1))
{
Console.WriteLine($"Shortest Title: {Movie.Title}");
}
var LongTitle = from Movie in MovieLoader.AllMovies
orderby Movie.Title.Length descending
select Movie;
foreach (var Movie in LongTitle.Take(1))
{
Console.WriteLine($"Longest Title: {Movie.Title}");
}
Console.WriteLine("************************************************");
//Rating, Widest Year Span
int Distance = 0, LowYear = 0, HighYear = 0, RcrdDist = 0;
MPAARating LongBoi = MPAARating.NotRated;
var RatingYears = from Movie in MovieLoader.AllMovies
group Movie by Movie.Rating into g
select g;
foreach (var Item in RatingYears)
{
foreach (var Movie in Item)
{
if (LowYear == 0 && HighYear == 0)
{
LowYear = Movie.Year;
HighYear = Movie.Year;
}
else if (LowYear == 0)
{
LowYear = Movie.Year;
}
else if (HighYear == 0)
{
HighYear = Movie.Year;
}
else if (Movie.Year > HighYear)
{
HighYear = Movie.Year;
}
else if (Movie.Year < LowYear)
{
LowYear = Movie.Year;
}
Distance = HighYear - LowYear;
if (Distance > RcrdDist)
{
RcrdDist = Distance;
LongBoi = Item.Key;
}
}
}
Console.WriteLine($"Rating: {LongBoi}, TimeSoan: {RcrdDist}");
Console.WriteLine("************************************************");
//Films per Decade over total year range
var Decades = from Movie in MovieLoader.AllMovies
group Movie by Movie.Year / 10 into g
orderby g.Key descending
select g;
foreach (var Item in Decades)
{
string MyString = Item.Key.ToString();
Console.WriteLine($"{MyString.Substring(2, 1) + 0}\'s: {Item.Count()}");
}
Console.WriteLine("************************************************");
//Unused Ratings in MPAARating Enum
bool UsedG = false, UsedNC17 = false, UsedNotRated = false, UsedPG = false, UsedPG13 = false, UsedR = false, UsedUnknown = false, UsedUnrated = false;
var UsedRatings = from Movie in MovieLoader.AllMovies
group Movie by Movie.Rating into g
select g;
foreach (var Item in UsedRatings)
{
//Console.WriteLine(Item.Key);
if (Item.Key == MPAARating.G && UsedG == false)
{
UsedG = true;
}
else if (Item.Key == MPAARating.NC17 && UsedNC17 == false)
{
UsedNC17 = true;
}
else if (Item.Key == MPAARating.NotRated && UsedNotRated == false)
{
UsedNotRated = true;
}
else if (Item.Key == MPAARating.PG && UsedPG == false)
{
UsedPG = true;
}
else if (Item.Key == MPAARating.PG13 && UsedPG13 == false)
{
UsedPG13 = true;
}
else if (Item.Key == MPAARating.R && UsedR == false)
{
UsedR = true;
}
else if (Item.Key == MPAARating.Unknown && UsedUnknown == false)
{
UsedUnknown = true;
}
else if (Item.Key == MPAARating.Unrated && UsedUnrated == false)
{
UsedUnrated = true;
}
}
if (UsedG != true)
{
Console.WriteLine("The G Rating is never used.");
}
if (UsedNC17 != true)
{
Console.WriteLine("The NC17 Rating is never used.");
}
if (UsedNotRated != true)
{
Console.WriteLine("The Not Rated Rating is never used.");
}
if (UsedPG != true)
{
Console.WriteLine("The PG Rating is never used.");
}
if (UsedPG13 != true)
{
Console.WriteLine("The PG13 Rating is never used.");
}
if (UsedR != true)
{
Console.WriteLine("The R Rating is never used.");
}
if (UsedUnknown != true)
{
Console.WriteLine("The Unknown Rating is never used.");
}
if (UsedUnrated != true)
{
Console.WriteLine("The Unrated Rating is never used.");
}
Console.WriteLine("************************************************");
//Display All Films, By rating (Ascending), then seperately by title (Ascending Alphabetically)
var RatingList = from Movie in MovieLoader.AllMovies
orderby Movie.Rating ascending
select Movie;
var TitleList = from Movie in MovieLoader.AllMovies
orderby Movie.Title descending
select Movie;
Console.WriteLine("Movies Sorted According to Ratings, Descending");
foreach (var Movie in RatingList)
{
Console.WriteLine($"{Movie.Title}, {Movie.Rating}");
}
Console.WriteLine("********************************");
Console.WriteLine("Movies Sorted According to Titles, Ascending");
foreach (var Movie in TitleList)
{
Console.WriteLine($"{Movie.Title}, {Movie.Rating}");
}
Console.WriteLine("************************************************");
//Group Movies by Number of Words in Title - List by Group with Total
var TitleLength = from Movie in MovieLoader.AllMovies
group Movie by Movie.Title.Length into g
select g;
foreach (var ItemList in TitleLength)
{
Console.WriteLine($"Group: {ItemList.Key}, Films: {ItemList.Count()}");
}
Console.WriteLine("************************************************");
//List Total Films with MPAARating of G, PG, PG-13 = total number
var KidFriendly = from Movie in MovieLoader.AllMovies
where Movie.Rating == MPAARating.G || Movie.Rating == MPAARating.PG || Movie.Rating == MPAARating.PG13
orderby Movie.Rating ascending
select Movie;
Console.WriteLine($"You could watch {KidFriendly.Count()} Movies. They are: ");
foreach (var Movie in KidFriendly)
{
Console.WriteLine($"{Movie.Title}, Rating: {Movie.Rating}");
}
Console.WriteLine("************************************************");
Console.Write("Press any key to continue...");
Console.ReadLine();
}
//TODO: DisplaySearchResults Method
public ActionResult DisplaySearchResults(String SearchString, String ReleaseYearString, BeforeAfter BeforeAfter, MPAARating MPAARating, List <int> SelectedGenres, String RatingString, String ActorString)
{
// create query
var query = from m in db.Movies
select m;
// TODO: make sure genre search is working, what does this do??
if (SelectedGenres != null)
{
List <Genre> SelGenres = new List <Genre>();
foreach (Genre item in db.Genres)
{
if (SelectedGenres.Contains(item.GenreID))
{
SelGenres.Add(item);
}
}
}
// search conditions
if (SearchString != null)
{
query = query.Where(m => m.Title.Contains(SearchString));
}
if (ReleaseYearString != null && ReleaseYearString != "")
{
try // ensure release year entry is valid
{
Int32 intReleaseYear = Convert.ToInt32(ReleaseYearString);
if (BeforeAfter == BeforeAfter.After)
{
query = query.Where(m => m.ReleaseDate.Year >= intReleaseYear);
}
if (BeforeAfter == BeforeAfter.Before)
{
query = query.Where(m => m.ReleaseDate.Year <= intReleaseYear);
}
}
catch // invalid, display error
{
ViewBag.ReleaseYearErrorMessage = "You must enter a valid number to search by Year";
//TODO: Create viewbag with all genres
return(View("DetailedSearch"));
}
}
if (MPAARating != MPAARating.All)
{
if (MPAARating == MPAARating.G)
{
query = query.Where(m => m.MPAARating == MPAARating.G);
}
if (MPAARating == MPAARating.PG)
{
query = query.Where(m => m.MPAARating == MPAARating.PG);
}
if (MPAARating == MPAARating.PG13)
{
query = query.Where(m => m.MPAARating == MPAARating.PG13);
}
if (MPAARating == MPAARating.R)
{
query = query.Where(m => m.MPAARating == MPAARating.R);
}
if (MPAARating == MPAARating.NC17)
{
query = query.Where(m => m.MPAARating == MPAARating.NC17);
}
}
if (SelectedGenres != null)
{
if (SelectedGenres.Count != 0)
{
query = query.Where(r => r.Genres.Any(x => SelectedGenres.Contains(x.GenreID)));
}
}
if (RatingString != null && RatingString != "")
{
try // ensure rating entry is valid
{
Decimal decRating = Convert.ToDecimal(RatingString);
query = query.Where(m => m.CustomerRatingAverage >= decRating);
}
catch // invalid, display error
{
ViewBag.RatingErrorMessage = "You must enter a valid number to search by Rating";
//TODO: Create viewbag with all genres
return(View("DetailedSearch"));
}
}
//TODO: Actor string detailed search will need to be found
if (ActorString != null)
{
query = query.Where(m => m.Actors.Contains(ActorString));
}
List <Movie> MoviesToDisplay = new List <Movie>();
MoviesToDisplay = query.ToList();
MoviesToDisplay.OrderByDescending(m => m.CustomerRatingAverage);
ViewBag.TotalMovies = db.Movies.Count();
ViewBag.SelectedMovies = MoviesToDisplay.Count();
return(View("Index", MoviesToDisplay));
}
public ActionResult DisplaySearchResults(bool ShowingOnly, String strTitle, String strTagline, Int32?intSelectedYear, MPAARating MPAArating, String strActors, Int32?SelectedGenre, DateTime?datSchedule)
{
//create query
var query = from m in db.Movies
select m;
if (ShowingOnly == true)
{
query = query.Where(m => m.Showings.Any(x => x.Movie.MovieID == m.MovieID));
}
//check to see if they selected something
if (strTitle != null)
{
//if they selected a search string, limit results to only repos that meet the criteria
query = query.Where(m => m.Title.Contains(strTitle));
}
if (strTagline != null)
{
query = query.Where(m => m.Tagline.Contains(strTagline));
}
if (intSelectedYear != null)
{
query = query.Where(m => m.ReleaseDate.Year == intSelectedYear);
}
if (MPAArating != MPAARating.Any)
{
if (MPAArating == MPAARating.G)
{
query = query.Where(m => m.MPAARating == MPAARating.G);
}
if (MPAArating == MPAARating.PG)
{
query = query.Where(m => m.MPAARating == MPAARating.PG);
}
if (MPAArating == MPAARating.PG13)
{
query = query.Where(m => m.MPAARating == MPAARating.PG13);
}
if (MPAArating == MPAARating.R)
{
query = query.Where(m => m.MPAARating == MPAARating.R);
}
if (MPAArating == MPAARating.Unrated)
{
query = query.Where(m => m.MPAARating == MPAARating.Unrated);
}
}
if (strActors != null)
{
query = query.Where(m => m.Actors.Contains(strActors));
}
if (SelectedGenre != null)
{
query = query.Where(m => m.Genres.Any(x => x.GenreID == SelectedGenre));
}
if (datSchedule != null)
{
query = query.Where(m => m.Showings.Any(x => x.Movie.MovieID == m.MovieID && x.ShowingDate == datSchedule));
}
//execute query
List <Movie> MoviesToDisplay = query.ToList();
ViewBag.TotalMovies = db.Movies.Count();
ViewBag.SelectedMovies = MoviesToDisplay.Count();
//order lsit
//MoviesToDisplay.OrderByDescending(r => r.StarCount);
if (MoviesToDisplay.Count == 0)
{
return(View("NoMovies"));
}
//send list to view
return(View("Index", MoviesToDisplay));
}
public ActionResult DisplayTicketSearchResults(ChosenReport RevenueOrSeats, DateTime?datBeginningDate, DateTime?datEndingDate, String MovieSearchString, MPAARating SelectedMPAARating, TimeOfDay Daytime)
{
var query = from t in db.Tickets
select t;
query = query.Where(t => t.Order.Gift == false);
query = query.Where(t => t.Order.CompletedOrder == true);
query = query.Where(t => t.Order.CancelledOrder == false);
query = query.Where(t => t.Order.PaymentMethod == PaymentMethod.Card);
query = query.Where(t => t.Taken == true);
if (datBeginningDate != null)
{
DateTime datBeginning = datBeginningDate ?? new DateTime(1900, 1, 1);
query = query.Where(t => t.Showtime.Schedule.ScheduleDate >= datBeginningDate);
}
if (datEndingDate != null)
{
DateTime datEnding = datEndingDate ?? DateTime.Today;
query = query.Where(t => t.Showtime.Schedule.ScheduleDate <= datEndingDate);
}
if (MovieSearchString != null && MovieSearchString != "")
{
query = query.Where(t => t.Showtime.Movie.Title.Contains(MovieSearchString));
}
if (SelectedMPAARating != MPAARating.All)
{
query = query.Where(t => t.Showtime.Movie.MPAARating == SelectedMPAARating);
}
if (Daytime != TimeOfDay.AllDay)
{
DateTime EndMorningTime = new DateTime(2000, 1, 1, 12, 0, 0);
DateTime EndAfternoonTime = new DateTime(2000, 1, 1, 17, 0, 0);
DateTime EndEveningTime = new DateTime(2000, 1, 1, 20, 0, 0);
switch (Daytime)
{
case TimeOfDay.Morning:
query = query.Where(t => t.Showtime.StartTime.Hour < EndMorningTime.Hour);
break;
case TimeOfDay.Afternoon:
query = query.Where(t => t.Showtime.StartTime.Hour >= EndMorningTime.Hour);
query = query.Where(t => t.Showtime.StartTime.Hour < EndAfternoonTime.Hour);
break;
case TimeOfDay.Evening:
query = query.Where(t => t.Showtime.StartTime.Hour >= EndAfternoonTime.Hour);
query = query.Where(t => t.Showtime.StartTime.Hour < EndEveningTime.Hour);
break;
case TimeOfDay.Night:
query = query.Where(t => t.Showtime.StartTime.Hour >= EndEveningTime.Hour);
break;
}
}
List <Ticket> Selected = query.ToList();
Decimal decTotalRevenue = (Selected.Sum(item => item.PriceAtPayment)) * 1.0825m;
String strTotalRevenue = decTotalRevenue.ToString("C");
Int32 intTotalSeats = Selected.Count();
switch (RevenueOrSeats)
{
case ChosenReport.Both:
ViewBag.TotalRevenue = strTotalRevenue;
ViewBag.TotalSeats = intTotalSeats;
break;
case ChosenReport.Revenue:
ViewBag.TotalRevenue = strTotalRevenue;
break;
case ChosenReport.SeatsSold:
ViewBag.TotalSeats = intTotalSeats;
break;
//TODO: Delete this comment
}
return(View("SummaryReport"));
}
public ActionResult DisplaySearchResults(String SearchTitle, String SearchTagline, Int32 SearchGenreID, MPAARating SearchMPAARating, String SearchStars, StarFilter SearchStarFilter, String SearchActor, YearFilter SearchYearFilter, String SearchYear)
{ // Update Actors and other fields to be multiselectable
var query = from m in db.Movies
select m;
Boolean SomethingWrong = false;
//SearchTitle for Movie Name
if (SearchTitle != null)
{
query = query.Where(m => m.Title.Contains(SearchTitle));
}
//SearchTagline for Movie Tagline
if (SearchTagline != null)
{
query = query.Where(m => m.Tagline.Contains(SearchTagline));
}
// SearchGenreID for Movie Genre
if (SearchGenreID != 0)
{
//Genre ThisGenre = db.Genres.FirstOrDefault(g => g.GenreID == SearchGenreID);
query = query.Where(m => m.Genres.Any(g => g.GenreID == SearchGenreID));
} // TODO: fix not being able to filter by Genre
//YEAR
//code for year text box
if (SearchYear != null && SearchYear != "")
{
DateTime dtSearchYear;
try
{
dtSearchYear = new DateTime(Convert.ToInt32(SearchYear), 1, 1);
}
catch
{
ViewBag.YearMessage = SearchYear + " is not a valid year. Please try again";
ViewBag.AllGenres = GetAllGenres();
ViewBag.AllMPAARatings = GetAllMPAARatings();
SomethingWrong = true;
dtSearchYear = DateTime.Now;
}
//code for radio buttons of year
if (SearchYearFilter == YearFilter.After && !SomethingWrong)
{
foreach (Movie m in query.ToList())
{
if (m.ReleaseDate < dtSearchYear)
{
query = query.Where(x => x.Title != m.Title);
}
}
}
else if (SearchYearFilter == YearFilter.Before)
{
foreach (Movie m in query.ToList())
{
if (m.ReleaseDate > dtSearchYear)
{
query = query.Where(x => x.Title != m.Title);
}
}
}
}
//code for MPAA Rating selection
if (SearchMPAARating != MPAARating.None)
{
query = query.Where(m => m.MPAARating == SearchMPAARating);
}
//code for customer rating text box
if (SearchStars != null && SearchStars != "")
{
Decimal decCustomerRating;
try
{
decCustomerRating = Convert.ToDecimal(SearchStars);
}
catch
{
ViewBag.Message = SearchStars + " is not a valid number. Please try again";
ViewBag.AllGenres = GetAllGenres();
ViewBag.AllMPAARatings = GetAllMPAARatings();
SomethingWrong = true;
decCustomerRating = -1;
}
//code for radio buttons
if (SearchStarFilter == StarFilter.Greater && !SomethingWrong)
{
foreach (Movie m in query.ToList())
{
if (m.RatingAverage < decCustomerRating)
{
query = query.Where(x => x.Title != m.Title);
}
}
}
else if (SearchStarFilter == StarFilter.Less)
{
foreach (Movie m in query.ToList())
{
if (m.RatingAverage > decCustomerRating)
{
query = query.Where(x => x.Title != m.Title);
}
}
}
}
// SearchActors for Movie Actors
if (SearchActor != null)
{
query = query.Where(m => m.Actors.Contains(SearchActor));
}
List <Movie> MoviesToDisplay = query.ToList();
MoviesToDisplay.OrderBy(m => m.Title);
ViewBag.SelectedMoviesCount = MoviesToDisplay.Count();
ViewBag.TotalMoviesCount = db.Movies.ToList().Count();
if (!SomethingWrong)
{
return(View("~/Views/Movies/Index.cshtml", MoviesToDisplay));
}
else
{
return(View("DetailedSearch"));
}
}
