public async Task GetPopularMovies_WhenCalled_ReturnMovieCollection()
{
var moviecollection = new MovieCollection();
//Arrange
var mockFactory = new Mock <IHttpClientFactory>();
var mockHttpMessageHandler = new Mock <HttpMessageHandler>();
mockHttpMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(moviecollection), Encoding.UTF8, "application/json")
});
var client = new HttpClient(mockHttpMessageHandler.Object);
client.BaseAddress = new Uri("https://api.themoviedb.org/3/");
mockFactory.Setup(_ => _.CreateClient("Movie Api")).Returns(client);
//act
var services = new MovieService(mockFactory.Object);
var result = await services.GetPopularMovies(1);
//assert
Assert.IsNotNull(result);
Assert.That(result, Is.TypeOf <MovieCollection>());
}
static MovieCollection GetMovieCollection()
{
var response = client.GetAsync("movies/").Result;
MovieCollection Movies = response.Content.ReadAsAsync <MovieCollection>().Result;
return(Movies);
}
static void RemoveMovie()
{
// display that is shown when a staff member chooses to remove a movie from the system
// user inputs the title of the movie (must match exactly)
// if the user input does not match the title of a movie already in the system, an error message will be displayed
// if not all copies of the movie have been returned, an error message will be displayed
Console.Clear();
Console.WriteLine("2. Remove a movie"); // heading
Console.WriteLine("");
Console.WriteLine("Input the name of the movie you would like removed:");
string input = Console.ReadLine();
if (MovieCollection.FindMovieInTree(input) != null) // checking if title matches a title in the system
{
Movie removedMovie = MovieCollection.FindMovieInTree(input).data; // finding the movie corresponding to the user input
if (removedMovie.TotalCopies != removedMovie.CopiesAvailable) // checking if there are any unreturned copies of the movie
{
Console.WriteLine("All movie copies must be returned before removing a movie from the system. Please try again later.");
}
else // if all copies have been returned
{
MovieCollection.RemoveMovieFromTree(removedMovie);
Console.WriteLine(removedMovie.Title + " was successfully removed. Press any key to return to the staff menu.");
Console.ReadKey();
}
}
else // if title does not correspond to a movie in the system
{
Console.WriteLine("Sorry, there are no records of " + input + " in our movie system.");
Console.ReadKey();
}
}
public MovieCollection ImportMoviesFromDumpFiles(string[] filesToRead, MovieCollection movieCollection)
{
var movieList = new List <Movie>();
foreach (var txtFile in filesToRead)
{
if (File.Exists(txtFile) && txtFile.Contains(".txt"))
{
var fileName = Path.GetFileNameWithoutExtension(txtFile);
var Encoding = EncodingDetector.DetectTextFileEncoding(txtFile);
var myFile = new StreamReader(txtFile, Encoding);
var moviesString = myFile.ReadToEnd();
myFile.Close();
moviesString = moviesString.Replace("last-modified |ext |size|name|location", string.Empty);
var moviesLines = moviesString.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
OnProgressUpdate?.Invoke(ImportProgressType.NewFile, fileName, moviesLines.Count());
foreach (var line in moviesLines)
{
if (line != "done" && !string.IsNullOrWhiteSpace(line))
{
var movie = FileHelper.GetMovieFromLine(line, fileName);
if (movie != null)
{
movieCollection.AddMovie(movie);
}
}
OnProgressUpdate?.Invoke(ImportProgressType.NewLine, string.Empty, 0);
}
}
}
return(movieCollection);
}
private MovieTag CopyMovieInfos(MovieTag movieTag, Movie movie)
{
movieTag.Title = movie.Title;
movieTag.IMDB_ID = movie.ImdbId;
movieTag.TMDB_ID = movie.Id.ToString();
MovieCollection collection = movie.Collection;
movieTag.CollectionTitle = collection != null ? collection.Name : null;
movieTag.ReleaseDate = movie.ReleaseDate.HasValue ? movie.ReleaseDate.Value.ToString("yyyy-MM-dd") : null;
movieTag.Overview = movie.Overview;
movieTag.Tagline = movie.Tagline;
//todo: implement certification
//movieTag.Certification = movie.
movieTag.Genres = movie.Genres.Select(g => g.Name).ToList().AsReadOnly();
MovieCasts casts = movieDbApi.GetCastCrew(movie.Id);
if (casts == null)
{
return(movieTag);
}
movieTag.Actors = casts.Cast.Select(p => p.Name).ToList().AsReadOnly();
movieTag.Directors = casts.Crew.Where(p => p.Job == "Director").Select(p => p.Name).ToList().AsReadOnly();
movieTag.Writers = casts.Crew.Where(p => p.Job == "Author").Select(p => p.Name).ToList().AsReadOnly();
return(movieTag);
}
public async Task <IActionResult> AddMovieToCollection([FromBody] AddMovieToCollectionRequest request)
{
MovieCollection collection = await this.movieCollections.GetById(request.collectionId);
if (collection == null)
{
return(NotFound(new ErrorResponse {
Error = "Invalid collection id"
}));
}
MovieCollectionItem movieCollectionItem = new MovieCollectionItem
{
MovieId = request.MovieId,
MovieCollectionId = collection.Id
};
if (await this.movieCollectionItems.Exists(request.MovieId, request.collectionId))
{
return(Conflict(new ErrorResponse {
Error = "Movie already added on collection"
}));
}
MovieCollectionItem movieOnCollection = await this.movieCollectionItems.Add(movieCollectionItem);
MovieCollectionItemResponse response = this.mapper.Map <MovieCollectionItemResponse>(movieOnCollection);
return(CreatedAtAction("GetCollectionById", new { collectionId = response.MovieCollectionId }, response));
}
public async Task <MovieCollection> GetById(int id)
{
MovieCollection movieCollection = null;
string sql = @"
SELECT `Name`, `Description`, `UserId`, `c`.`Id`, `MovieCollectionId`, `MovieId`,`u`.`Id`, `FirstName`, `LastName`, `Username`
FROM MovieCollections as c
LEFT JOIN MovieCollectionItems as i
ON c.Id = i.MovieCollectionId
JOIN Users as u
ON c.UserId = u.Id
WHERE c.Id = @id;";
using (var conn = GetConnection())
{
var queryResults = await conn.QueryAsync <MovieCollection, MovieCollectionItem, User, MovieCollection>(sql,
(currentMovieCollection, movieItem, user) => {
if (movieCollection == null)
{
currentMovieCollection.User = user;
movieCollection = currentMovieCollection;
}
if (movieItem != null)
{
movieCollection.MovieCollectionItems.Add(movieItem);
}
return(null);
}, new { id = id }, splitOn : "MovieCollectionId, Id");
}
return(movieCollection);
}
public async Task <IActionResult> CreateCollection([FromBody] CreateCollectionRequest request)
{
User user = await this.users.GetById(request.Uid);
if (user == null)
{
return(BadRequest(new ErrorResponse {
Error = "Invalid User Id."
}));
}
MovieCollection collectionToAdd = new MovieCollection
{
User = user,
Name = request.Name,
Description = request.Description
};
if ((await this.movieCollections.CollectionNameExists(collectionToAdd)))
{
return(Conflict(new ErrorResponse {
Error = "Collection name already in use."
}));
}
MovieCollection addedCollection = await this.movieCollections.Add(collectionToAdd);
MovieCollectionResponse response = this.mapper.Map <MovieCollectionResponse>(addedCollection);
return(CreatedAtAction("GetCollectionById", new { collectionId = response.Id }, response));
}
private static MovieCollection GetAllMovies()
{
var allMovieResponse = client.GetAsync("movies/").Result;
MovieCollection allMovies = allMovieResponse.Content.ReadAsAsync <MovieCollection>().Result;
return(allMovies);
}
/// <summary>
/// Renders the display all movies screen
/// </summary>
private static void DisplayAll()
{
Console.Clear();
Console.WriteLine("===========All Movies============");
var movies = MovieCollection.List();
if (movies.Length == 0)
{
Console.WriteLine(" No Movies");
}
for (int i = 0; i < movies.Length; i++)
{
var movie = movies[i];
Console.WriteLine($" {i+1}. {movie.Title}");
Console.WriteLine($" Starring: {movie.Starring}");
Console.WriteLine($" Director: {movie.Director}");
Console.WriteLine($" Duration: {movie.Duration} minutes");
Console.WriteLine($" Genre: {movie.Genre.ToString()}");
Console.WriteLine($" Classification: {movie.Classification.ToString()}");
Console.WriteLine($" Release Date: {movie.ReleaseDate.ToString()}");
Console.WriteLine($" Copies: {movie.Copies}");
Console.WriteLine($" Available Copies: {movie.Copies - movie.GetBorrowed()}");
}
End();
}
public async Task CreateMovieCollectionToMovieRelationship(MovieCollection movieCollection, Movie movie)
{
var relation = Relation.Instanciate(MovieCollection.ENTITY_CATEGORY_ID, movieCollection.GetId(),
Movie.ENTITY_CATEGORY_ID, movie.GetId(), Relation.RELATION_STATUS_ACTIVE_ID, DateTime.Now);
await Save(relation);
}
/// <Summary Get Collection>
/// Get collection of Games. If no records to return, GameCollection will be null.
/// </summary>
/// <returns></returns>
public static MovieCollection GetCollection()
{
MovieCollection tempList = null;
using (SqlConnection myConnection = new SqlConnection(AppConfiguration.ConnectionString))
{
using (SqlCommand myCommand = new SqlCommand("usp_GETMOVIE", myConnection))
{
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.AddWithValue("@QueryId", MovieSelectTypeEnums.GetCollection);
myConnection.Open();
using (SqlDataReader myReader = myCommand.ExecuteReader())
{
if (myReader.HasRows)
{
tempList = new MovieCollection();
while (myReader.Read())
{
tempList.Add(FillDataRecord(myReader));
}
}
myReader.Close();
}
}
}
return tempList;
}
/// <summary>
/// Renders the Add Movice functionality
/// </summary>
private static void AddMovie()
{
Console.Clear();
Console.WriteLine("==========Create Movie============");
var title = Input.ReadString(" Title: ");
var starring = Input.ReadString(" Starring: ");
var director = Input.ReadString(" Director: ");
var duration = Input.ReadInt(" Duration (minutes): ");
for (int i = 0; i < 8; i++)
{
Console.WriteLine($" {i}: {(Genre)i}");
}
var genre = (Genre)Input.ReadInt(" Genre [0-7]: ", new Regex("[0-7]"));
for (int i = 0; i < 4; i++)
{
Console.WriteLine($" {i}: {(Classification)i}");
}
var classification = (Classification)Input.ReadInt(" Classification [0-3]: ", new Regex("[0-3]"));
var releaseDate = Input.ReadString(" Release Date (DD/MM/YYYY): ", new Regex("[0-9][0-9]/[0-9][0-9]/[0-9][0-9][0-9][0-9]"));
var copies = Input.ReadInt(" Copies: ");
MovieCollection.AddMovie(new Movie(title, starring, director, duration, genre, classification, DateTime.Parse(releaseDate), copies));
Console.WriteLine(" Successfully Entered Movie");
End();
}
private MovieDTOCollection MovieCollectionToDTO(MovieCollection movieCollection)
{
MovieDTOCollection tempList = new MovieDTOCollection();
MovieDTO tempItem;
if (movieCollection != null)
{
foreach (Movie item in movieCollection)
{
tempItem = new MovieDTO();
tempItem.MovieId = item.MovieId;
if (item.MovieTitle != null)
{
tempItem.MovieTitle = item.MovieTitle;
}
if (item.RatingName != null)
{
tempItem.RatingsName = item.RatingName;
}
if (item.YearReleased != null)
{
tempItem.YearReleased = item.YearReleased.ToString();
}
tempList.Add(tempItem);
}
}
return tempList;
}
public async Task <MovieCollection> GetMovies()
{
HttpClient client;
MovieCollection movies = null;
try
{
client = new HttpClient();
client.MaxResponseContentBufferSize = 256000;
HttpResponseMessage response = null;
var uri = new Uri("https://copadosfilmes.azurewebsites.net/api/filmes");
response = await client.GetAsync(uri);
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
movies = JsonConvert.DeserializeObject <MovieCollection>(content);
}
}
catch (Exception ex)
{
movies.Error = true;
movies.Message = ex.Message.ToString();
}
return(movies);
}
static void Main(string[] args)
{
var collection = new MovieCollection(new DummyDatabase());
collection = new Importer().ImportMoviesFromDumpFiles(Directory.GetFiles(GetDumpDirectory()), collection);
Console.WriteLine(string.Format("{0} Movies imported", collection.Movies.Count));
CreateScripts(collection);
}
public override void OnSaveState(bool suspending, Dictionary <string, object> state)
{
state["MovieCollection"] = MovieCollection.ToSurrogate();
state["VerticalOffset"] = VerticalOffset;
state["SelectedGenre"] = SelectedGenre;
state["SelectedSort"] = SelectedSort;
state["SearchTerm"] = SearchTerm;
}
private CollectionModel ConvertEntityToCollectionModel(MovieCollection entity)
{
return(new CollectionModel
{
Id = entity.Id,
Name = entity.Name
});
}
public ActionResult <MovieCollection> PostMovies([FromBody] MovieCollection movies)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(application.GetResultCupMovies(movies));
}
/// <summary>
/// Creates a new member with no borrowed films.
/// </summary>
/// <param name="firstNmae">First name</param>
/// <param name="surName">Sur-Name</param>
/// <param name="phoneNumber">Phone number</param>
/// <param name="password">the 4 didget numeric password</param>
/// <param name="adress">The full address</param>
public Member(string firstNmae, string surName, string phoneNumber, string password, string adress)
{
this.firstNmae = firstNmae;
this.surName = surName;
this.phonenumber = phoneNumber;
this.password = password;
this.adress = adress;
borrowed = new MovieCollection();
}
public DeleteMovieCommand(MovieCollection collection, INavigator navigator, IChangeTracker changeTracker)
{
Ensure.NotNull(collection, "collection");
Ensure.NotNull(navigator, "navigator");
Ensure.NotNull(changeTracker, "changeTracker");
this.collection = collection;
this.navigator = navigator;
this.changeTracker = changeTracker;
}
public Member(string firstName, string surname, string address, string phone, string password, MovieCollection movies)
{
FirstName = firstName;
Surname = surname;
Address = address;
Phone = phone;
Password = password;
Movies = movies;
}
public MovieController(IWebHostEnvironment environment)
{
this._environment = environment;
movieCollection = new Factory().GetMovieCollection(Context.Database);
ratingCollection = new Factory().GetRatingCollection(Context.Database);
watchListCollection = new Factory().GetWatchListCollection();
}
private static void ShowAllMovies(MovieCollection movies)
{
var movielist = movies.Results.ToList();
foreach (var m in movielist)
{
Console.WriteLine($"Id: {m.Id}");
Console.WriteLine($"Title: {m.Title}");
}
}
/// <summary>
/// Displays the remove a movie functionality
/// </summary>
private static void RemoveMovie()
{
Console.Clear();
Console.WriteLine("==========Delete Movie============");
var title = Input.ReadString(" Movie Title: ");
MovieCollection.RemoveMovie(title);
Console.WriteLine(" Successfully Deleted");
End();
}
public MovieDto ToDto(MovieCollection movieDto)
{
return(new MovieDto
{
Id = movieDto.Id,
Name = movieDto.Name,
Description = movieDto.Description,
CreatedDateTime = movieDto.CreatedDateTime,
ModifiedDateTime = movieDto.ModifiedDateTime
});
}
public void Transfer_Movies_To_OtherStore_UpdatesBothAccount()
{
var otherStore = new MovieCollection();
//Act
movie.TransferToOtherStores(otherStore, 200);
//Assert
Assert.AreEqual(300, movie.Inventory);
Assert.AreEqual(200, otherStore.Inventory);
}
private static void CreateScripts(MovieCollection collection)
{
Console.WriteLine("Using default Filter for Duplicates: Name, Episode, Part, Language");
var duplicates = new DuplicateFinder().FindDuplicates(collection.Movies, _defaultFilter);
Console.WriteLine(string.Format("{0} duplicates found", duplicates.Count()));
CreateCopyScriptFile(collection, duplicates);
CreateDeleteScriptFile(collection, duplicates);
Console.WriteLine("Script creation finished!...");
Console.ReadLine();
}
public async Task <CollectionModel> AddCollectionAsync(AddCollectionInput model, long currentUserId)
{
var entity = new MovieCollection
{
Name = model.Name,
UserId = currentUserId
};
await collectionMovieRepo.AddAsync(entity);
return(ConvertEntityToCollectionModel(entity));
}
private Movie GetRoundSeller(MovieCollection moviesRound)
{
moviesRound.OrderByDescendingNote();
var movieFirst = moviesRound[0];
var movieSecund = moviesRound[1];
if (movieFirst.Nota == movieSecund.Nota)
{
return(TieBreaker(moviesRound));
}
return(movieFirst);
}
public void ClearListCommandExecute(string param)
{
if (visibleMoviePivot)
{
MovieCollection.Clear();
RaisePropertyChanged("NumResultsMovies");
}
else
{
TvShowCollection.Clear();
RaisePropertyChanged("NumResultsTvShows");
}
}
public IActionResult MovieForm(MovieCollection appResponse)
{
if (ModelState.IsValid)
{
TempStorage.AddMovie(appResponse);
return(View("Confirmation", appResponse));
}
else
{
return(View("MovieForm"));
}
}
public void SetUp()
{
_movie = new Movie(MovieId, MovieName);
_movieCollection = new MovieCollection();
}
public void SetUp()
{
_collection = new MovieCollection();
}
public void SetUp()
{
_collection = new MovieCollection(new FakeStorage());
}
