public void Repository_Movie_deveria_gravar_um_novo_filme()
{
//Arrange
Movie result = _repository.Add(_movie);
result.Id.Should().BeGreaterThan(0);
}
static void Main(string[] args)
{
IMovieRepository repository = new MovieRepository();
repository.Add(new MovieModel {
Id = 1, Category = CategoryEnum.CLASSIC, Title = "The man"
});
repository.Add(new MovieModel {
Id = 2, Category = CategoryEnum.ACTION, Title = "Batman Begins"
});
repository.Add(new MovieModel {
Id = 3, Category = CategoryEnum.THRILLER, Title = "2:22"
});
//var list = repository.GetAll();
var list = repository.FindByTitle("ma");
foreach (MovieModel b in list)
{
Console.WriteLine(string.Format(
"#{0} | Category: {1} | Title: {2}", b.Id, b.Category, b.Title
));
}
Console.ReadKey();
}
public async Task TestAddMovie()
{
var movie = new TblMovie();
movie.MovieId = Guid.NewGuid();
Assert.True(await repo.Add(movie));
}
public ActionResult Save(String save)
{
List <String> messages = new List <string>();
if (save == "Yes")
{
BulkLoadOutput blo = (BulkLoadOutput)TempData["blo"];
List <Movie> movies = blo == null?
new List <Movie>():blo.ResolvedMovie;
MovieRepository rep = new MovieRepository();
foreach (Movie m in movies)
{
try
{
rep.Add(m);
rep.Save();
messages.Add("Successfully add movie " + m.Title);
}
catch
{
messages.Add("Unable to add movie " + m.Title + ". Perhaps it is already in database.");
}
}
}
else
{
messages.Add("Bulk Load operation is successfully cancelled.");
}
return(View(messages));
}
public ActionResult Create(Movie movie)
{
try
{
rep.Add(movie);
rep.Save();
return(RedirectToAction("Index"));
}
catch (Exception e)
{
if (e.GetType() != typeof(DbEntityValidationException))
{
if (this.HttpContext.IsCustomErrorEnabled)
{
ModelState.AddModelError(string.Empty, e.ToString());
}
else
{
ModelState.AddModelError(string.Empty, "Some Technical error happened!");
}
}
return(View(movie));
}
}
public bool Add(MovieDto model, out string id)
{
var mapper = MapperToModel();
var movie = mapper.Map <MovieDto, Movie>(model);
return(_movieRepository.Add(movie, out id));
}
private async Task <RequestEngineResult> AddMovieRequest(MovieRequests model, string movieName, string requestOnBehalf)
{
await MovieRepository.Add(model);
var result = await RunSpecificRule(model, SpecificRules.CanSendNotification, requestOnBehalf);
if (result.Success)
{
await NotificationHelper.NewRequest(model);
}
await _mediaCacheService.Purge();
await _requestLog.Add(new RequestLog
{
UserId = requestOnBehalf.HasValue() ? requestOnBehalf : (await GetUser()).Id,
RequestDate = DateTime.UtcNow,
RequestId = model.Id,
RequestType = RequestType.Movie,
});
return(new RequestEngineResult {
Result = true, Message = $"{movieName} has been successfully added!", RequestId = model.Id
});
}
public void Post([FromBody] Movie newMovie)
{
if (ModelState.IsValid)
{
movieRepository.Add(newMovie);
}
else
{
throw new HttpException(400, "Bad Request");
}
}
public ActionResult Create(Movie newMovie)
{
if (ModelState.IsValid)
{
var repository = new MovieRepository();
repository.Add(newMovie);
return(RedirectToAction("Index"));
}
else
{
return(View(newMovie));
}
}
public void Movies_Repository_Should_Add_Sucessfully()
{
//Action
var movie = _repository.Add(_movie);
//Assert
movie.Should().NotBeNull();
movie.Id.Should().NotBe(0);
var expectedMovie = _context.Movies.Find(movie.Id);
expectedMovie.Should().NotBeNull();
expectedMovie.Name.Should().Be(movie.Name);
}
public void AddMovie_Returns_NewMovie()
{
//Arrange
var _movie = new Movie {
id = 354443, name = "Lost world", posterPath = "lost.jpg", releaseDate = "05-01-2010", comments = string.Empty, voteAverage = 7.8, voteCount = 980
};
//Act
var actual = movierepo.Add(_movie);
//Assert
Assert.IsAssignableFrom <Movie>(actual);
}
public void Post([FromBody] Movie movie)
{
int moviesCount = movieRepository.GetAll().Where(x => x.MovieName.ToLower() == movie.MovieName.ToLower()).ToList().Count();
if (moviesCount > 0)
{
return;
}
if (ModelState.IsValid)
{
movieRepository.Add(movie);
}
}
private static void ImportTitles(string filepath, MovieRepository repo)
{
var reader = File.OpenText(filepath + "movie_titles.csv");
repo.DeleteGenres();
//repo.DeleteAll();
var titlesimported = 0;
int testlimit = 0;
while (!reader.EndOfStream && testlimit < Int32.MaxValue)
{
string line = reader.ReadLine();
var items = line.Split(",".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
int year, id;
if (Int32.TryParse(items[0], out id) && Int32.TryParse(items[1], out year) && !string.IsNullOrEmpty(items[2]))
{
Movie m = new Movie()
{
Id = Int32.Parse(items[0]),
Year = Int32.Parse(items[1]),
Title = items[2]
};
OMDBItem o = repo.GetOMDBData(m.Title);
if (o != null && o.imdbID != null)
{
m.IMDBId = o.imdbID;
m.PosterUrl = "http://img.omdbapi.com/?i=" + m.IMDBId + "&h=200&apikey=7e6ca2d5";
repo.DeleteById(m);
repo.Add(m);
repo.AddGenresForMovie(m.Id, o.Genre);
titlesimported++;
}
testlimit++;
}
}
Console.WriteLine(titlesimported + " titles imported");
}
public ActionResult Create(Movie newMovie, IFormCollection collection)
{
try
{
// TODO: Add insert logic here
_movieRepo.Add(newMovie);
return(RedirectToAction(nameof(Index)));
}
catch
{
return(View());
}
}
public void Execute()
{
MovieRepository.Add(Command.Movie);
if (!MovieRepository.SaveChanges())
{
Command.WasSuccesful = false;
Command.ErrorMessage = "Creating failed on save";
}
else
{
Command.WasSuccesful = true;
}
}
public void ContextTest()
{
MainContext context = new MainContext("MainConnection");
MovieRepository repository = new MovieRepository(context);
var movie = repository.Add(new MovieDomain.Entities.Movie
{
Title = "Good Will Hunting"
});
repository.Commit();
Assert.IsNotNull(movie);
}
public IHttpActionResult AddMovie([FromBody] MovieDTO movieDTO)
{
Movie movie = new Movie();
AutoMapper.Mapper.Map(movieDTO, movie);
if (MovieRepository.Add(movie))
{
return(Ok("Movie was added."));
}
else
{
return(BadRequest("Movie was not added!"));
}
}
public ActionResult Create(Movie movie)
{
try
{
rep.Add(movie);
rep.Save();
// TODO: Add insert logic here
return(RedirectToAction("Index"));
}
catch
{
return(View(movie));
}
}
public IHttpActionResult Add(AddMovieRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Movie movie = new Movie()
{
Title = request.Title,
Rating = request.Rating
};
MovieRepository.Add(movie);
return(Created($"movies/get/{movie.MovieId}", movie));
}
public Movie Create(MovieCreateDto dto)
{
string imageName = fileService.Save(dto.Upload);
var entity = new Movie
{
Title = dto.Title,
Content = dto.Content,
Tags = dto.Tags != null?string.Join(',', dto.Tags) : null,
Img = imageName,
CategoryId = dto.CategoryId,
Length = dto.Length,
CreatedAt = System.DateTime.Now,
Released = dateTimeUtils.Parse(dto.Released)
};
return(repository.Add(entity));
}
public void TestAddMovieOk()
{
Movie movie = new Movie()
{
Name = "Elona Holmes",
AgeAllowed = 12,
CategoryId = 1,
Description = "La herama de Sherlock y Mycroft Holmes",
Duration = 2.1,
Image = "Mi directorio",
};
var repository = new MovieRepository(this.context);
var result = repository.Add(movie);
Assert.AreEqual(repository.GetAll().Count(), 1);
}
public async Task Test_Add_Movie_Should_Be_Ok()
{
var fakeMovie = new Movie
{
Name = "Fake movie name",
GenreId = 2 // Ficção
};
var movieId = await movieRepository.Add(fakeMovie);
movieId.Should().BeGreaterThan(0);
var result = await rentalContext.Movies.SingleAsync(m => m.Name == fakeMovie.Name);
result.Should().NotBeNull();
result.Id.Should().Be(movieId);
mapperMock.VerifyNoOtherCalls();
}
public async Task CanAddMovie()
{
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
try
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseSqlite(connection)
.Options;
using (var context = new ApplicationDbContext(options))
{
context.Database.EnsureCreated();
}
var movie = new Movie
{
Id = Guid.NewGuid(),
Director = "Shelby Mansker",
Name = "test_movie_1"
};
using (var context = new ApplicationDbContext(options))
{
var repo = new MovieRepository(context);
await repo.Add(movie);
}
using (var context = new ApplicationDbContext(options))
{
Assert.AreEqual(1, context.Movies.Count());
Assert.AreEqual("test_movie_1", context.Movies.Single().Name);
}
}
finally
{
connection.Close();
}
}
private async Task <RequestEngineResult> AddMovieRequest(MovieRequests model, string movieName)
{
await MovieRepository.Add(model);
var result = await RunSpecificRule(model, SpecificRules.CanSendNotification);
if (result.Success)
{
NotificationHelper.NewRequest(model);
}
await _requestLog.Add(new RequestLog
{
UserId = (await GetUser()).Id,
RequestDate = DateTime.UtcNow,
RequestId = model.Id,
RequestType = RequestType.Movie,
});
return(new RequestEngineResult {
Result = true, Message = $"{movieName} has been successfully added!"
});
}
public void Test_Add_ListAll()
{
Movie mov = new Movie() { Id = 20, Title = "Avengers: Age Of Ultron", Genre = new Genre() { Id = 2, Name = "Action" }, Price = 150, Year = DateTime.Now.Date, ImgUrl = "http://scaled.ysimag.es/movie/the-avengers-age-of-ultron", TrailerUrl = "https://www.youtube.com/watch?v=S2HIda5wSVU" };
mov.Id = 1;
mov.Title = "Alice in Wonderland";
mov.Genre.Id = 2;
mov.Genre.Name = "Action";
mov.Price = 150;
mov.ImgUrl = "http://scaled.ysimag.es/movie/the-avengers-age-of-ultron";
mov.TrailerUrl = "https://www.youtube.com/watch?v=S2HIda5wSVU";
mov.Year = DateTime.Now.Date;
MovieRepository repository = new MovieRepository();
int numberOfMovies = repository.GetAll().Count();
Movie result = repository.Add(mov);
Assert.NotNull(result);
int finalNumberOfMovies = repository.GetAll().Count();
Assert.AreEqual(numberOfMovies + 1, finalNumberOfMovies);
}
public IActionResult AddMovie(Movie movie)
{
_movieRepository.Add(movie);
return(CreatedAtAction(nameof(Get), new { id = movie.Id }, movie));
}
public void AddMovie(movie movie)
{
_movieRepository.Add(movie);
}
static void GetImportedMovies()
{
//import movies from json file: importedmovies.json
var importedmovies = _movieRepository.GetImportedMovies();
var movies = _movieRepository.Get();
//importedmovies.json file / movies.json file is needed to show movies
if (!importedmovies.Any() && !movies.Any())
{
Console.WriteLine("The file: importedmovies.json is needed for import. Please add it to folder: User\\Documents\\Project\\Movies\\Movies\\bin\\Debug");
}
else
{
if (!movies.Any())
{
Console.WriteLine($"Importing movies from external file...");
foreach (var importedmovie in importedmovies)
{
//----for each movie in importedmovie.json add list of cast and genre -------
//------------- Cast - start -------------------------------
var newListCast = new List <Cast>();
var cast = importedmovie.Cast;
//--------- loop thru cast in string array format from importedmovies.json
//--------- to create List of Cast to be inserted into Movies.json -------
foreach (String c in cast)
{
//----- create new cast for one movie -------
var newCast = new Cast
{
Name = c
};
int newCastId = _castRepository.Add(newCast);
newCast = _castRepository.Get(newCastId); // Get new cast along with id
newListCast.Add(newCast); //Add to Cast List collection
//Console.WriteLine($"New Cast Id: {newCastId} {c}");
//----- create new cast for one movie -------
}
//------------- Cast - End ---------------------------------
//------------- Genres - start -------------------------------
var newListGenres = new List <Genre>();
var genre = importedmovie.Genres;
foreach (String g in genre)
{
//----- create new cast for one movie -------
var newGenre = new Genre
{
Category = g
};
int newGenreId = _genreRepository.Add(newGenre);
newGenre = _genreRepository.Get(newGenreId); // Get new cast along with id
newListGenres.Add(newGenre); //Add to Cast List collection
//Console.WriteLine($"New Genre Id: {newGenreId} {g}");
//----- create new cast for one movie -------
}
//------------- Genres - End -------------------------------
//------------- Add Movie start ----------------------
var newMovie = new Movie()
{
Title = importedmovie.Title,
Year = importedmovie.Year,
Cast = newListCast, //includes List of casts
Genre = newListGenres //includes List of genres
};
int newMovieId = _movieRepository.Add(newMovie);
//------------- Add Movie end-------------------------
Console.WriteLine($"Movie: {newMovieId} {importedmovie.Title}, {importedmovie.Year}");
newMovie = _movieRepository.Get(newMovieId);
}
}
}
Clear();
}
public List <Movie> AddMovie(Movie item)
{
mrep.Add(item);
mrep.Save();
return(GetAllMovies());
}
public ActionResult AddMovie([Bind(Prefix = "Movie")] Movie item, HttpPostedFileBase resim)
{
item.MovieImagePath = ImageUploader.UploadImage("~/Pictures/", resim);
_mvRep.Add(item);
return(RedirectToAction("MovieList"));
}
