public void DeleteShouldDeleteMovie()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteShouldDeleteMovie))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var userService = new UserService(context, config, registerValidator, roleValidator);
userService.Register(user);
var addedUser = context.Users.Last();
movieService.Create(movie, addedUser);
var addedMovie = context.Movies.Last();
int id = addedMovie.Id;
Movie deletedMovie = movieService.Delete(id);
int movies = movieService.GetAll(1).Entries.Count();
Assert.AreEqual(0, movies);
}
}
public void CreateShouldAddAndReturnTheCreatedMovie()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldAddAndReturnTheCreatedMovie))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var added = movieService.Create(new WebApplication3.ViewModels.MoviePostModel
{
Title = "Titanic",
Duration = 100,
Genre = "Thriller",
WatchedState = "Yes",
DateAdded = DateTime.Parse("2019-06-15T00:00:00"),
DateClosed = null,
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "A nice movie",
}
},
}, null);
Assert.IsNotNull(added);
Assert.AreEqual("Titanic", added.Title);
Assert.AreNotEqual("Mask", added.Title);
}
}
public void TestCreateMovieCount()
{
var options = new DbContextOptionsBuilder <MusicSpotDbContext>().UseInMemoryDatabase("createMovieReturnCount").Options;
var dbContext = new MusicSpotDbContext(options);
var service = new MovieService(dbContext);
var movie = new Movie
{
Title = "Speed",
Genre = "Action",
ImageUrl = "aaa",
Year = 1998,
Description = "some description",
UserId = "aaa"
};
for (int i = 1; i < 5; i++)
{
service.Create(movie.Title, movie.Genre, movie.ImageUrl, movie.Year, movie.Description, movie.UserId);
dbContext.SaveChanges();
}
dbContext.SaveChanges();
int result = dbContext.Movies.CountAsync().Result;
Assert.AreEqual(4, result);
Assert.AreNotEqual(14, result);
Assert.AreNotEqual("aa", result);
Assert.That(result, Is.Not.Null);
Assert.That(movie.Id, Is.Not.Null);
dbContext.Remove(movie);
}
public void GetByIdShouldReturnMovieById()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnMovieById))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var userService = new UserService(context, config, registerValidator, roleValidator);
userService.Register(user);
var addedUser = context.Users.Last();
movieService.Create(movie, addedUser);
var addedMovie = context.Movies.Last();
int id = addedMovie.Id;
Movie movieById = movieService.GetById(id);
Assert.AreEqual(movieById.Owner, addedMovie.Owner);
}
}
public void DeleteMovieTest()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteMovieTest))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var addedMovie = movieService.Create(new Lab3Movie.ViewModels.MoviePostModel
{
Title = "movie 1",
Description = "agfas",
Genre = "comedy",
DurationInMinutes = 100,
YearOfRelease = 2019,
Director = "director1",
Rating = 10,
Watched = "yes",
DateAdded = new DateTime(),
Comments = new List <Comment>()
{
new Comment
{
Text = "text",
Important = true,
Owner = null
}
},
}, null);
var movieDeleted = movieService.Delete(addedMovie.Id);
Assert.IsNotNull(movieDeleted);
}
}
public void GetAllShouldReturnCorrectNumberOfPages()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPages))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var addedTask = movieService.Create(new Lab3Movie.ViewModels.MoviePostModel
{
Title = "movie 1",
Description = "agfas",
Genre = "comedy",
DurationInMinutes = 100,
YearOfRelease = 2019,
Director = "director1",
Rating = 10,
Watched = "yes",
DateAdded = new DateTime(),
Comments = new List <Comment>()
{
new Comment
{
Text = "text",
Important = true,
Owner = null
}
},
}, null);
var allMovies = movieService.GetAll(1);
Assert.NotNull(allMovies);
}
}
public void GetAllShouldReturnAllComments()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllComments))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var userService = new UserService(context, config, registerValidator, roleValidator);
var commentService = new CommentService(context);
userService.Register(user);
var addedUser = context.Users.Last();
movieService.Create(movie, addedUser);
var addedMovie = context.Movies.Last();
int allComments = commentService.GetAll().Count();
Assert.AreEqual(3, allComments);
}
}
public IActionResult Create([FromBody] MovieDto movie)
{
if (movieService.Create(movie))
{
return(NoContent());
}
return(BadRequest());
}
public ActionResult Create(Movie movie)
{
if (ModelState.IsValid)
{
movieService.Create(movie);
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public void UpsertShouldModifyTheGivenMovie()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldModifyTheGivenMovie))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var added = new MoviePostModel()
{
Title = "Titanic",
Duration = 100,
Genre = "Thriller",
WatchedState = "Yes",
DateAdded = DateTime.Parse("2019-06-15T00:00:00"),
DateClosed = null,
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "A nice movie",
}
},
};
var toAdd = movieService.Create(added, null);
var update = new MoviePostModel()
{
Title = "Updated"
};
var toUp = movieService.Create(update, null);
var updateResult = movieService.Upsert(toUp.Id, toUp);
Assert.IsNotNull(updateResult);
Assert.AreEqual(toUp.Title, updateResult.Title);
}
}
public string Create(MovieDto movie)
{
if (!movie.IsValid())
{
return("Invalid movie");
}
bool isCreated = movieService.Create(movie);
return(isCreated ? "Movie added successfully." : "Failed to create the movie.");
}
public void Create_Movie_And_Movies_Count_Should_One()
{
var movie = ReturnAddMovieData();
var context = new MovieContext(_dbContextOptions);
{
var movieService = new MovieService(context);
movieService.Create(movie);
Assert.AreEqual(1, context.Movies.Count());
}
}
public ActionResult Create([Bind(Include = "Id,Title,Description,CreatedDate,CreatedBy,UpdatedDate,UpdatedBy")] Movie movie)
{
if (ModelState.IsValid)
{
_movieService.Create(movie);
return(RedirectToAction("Index"));
}
return(View(movie));
}
public ActionResult AddMovieToCollection(string imbdId, string userId, string comment, decimal rating)
{
ImdbMovie movie = _imdb.GetMovieFromIdAsync(imbdId).Result;
if (_movieService.Exists(movie.ImdbId) == false)
{
_movieService.Create(movie);
}
var movieCollection = _userService.AddMovieToCollection(ObjectId.Parse(userId), movie, comment, rating);
return(CreatedAtAction("GetMovieCollection", new { id = movieCollection.Id }, movieCollection));
}
public async Task <ActionResult <Movie> > Create(Movie movie)
{
try
{
var data = await _movieService.Create(movie);
return(Ok(data));
}
catch (System.Exception)
{
return(BadRequest());
}
}
public IActionResult OnPost()
{
try
{
service.Create(CreateDto);
return(Redirect("./Index"));
}
catch (Exception exception)
{
InitData();
ErrorMessage = exception.Message;
return(Page());
}
}
public void GetCommentsFilteredByValueShouldReturnAListOfFilteredComments()
{
var options = new DbContextOptionsBuilder <DataDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetCommentsFilteredByValueShouldReturnAListOfFilteredComments))
.Options;
using (var context = new DataDbContext(options))
{
var commentsService = new CommentService(context);
var movieService = new MovieService(context);
var MovieWithComments = new MoviePostModel()
{
Title = "Nu Stiu",
Description = "SF",
MovieGenre = "Comedy",
DurationInMinutes = 120,
ReleseYear = 2018,
Director = "Alexandru",
DateAdded = new DateTime(03 / 06 / 2019),
Rating = 3,
WasWatched = "YES",
Comments = new List <CommentGetModel>()
{
new CommentGetModel()
{
Text = "A test comment 1 filtered",
Important = false
},
new CommentGetModel()
{
Text = "A test comment 2 filtered",
Important = true
},
new CommentGetModel()
{
Text = "A test comment 3",
Important = false
}
}
};
movieService.Create(MovieWithComments);
List <CommentGetModel> comments = commentsService.GetAllComments("filtered");
int numberOfComments = comments.Count;
Assert.IsNotNull(comments);
Assert.AreEqual(2, numberOfComments);
}
}
public void CreateShouldReturnTheCreatedMovie()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(CreateShouldReturnTheCreatedMovie))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var userService = new UserService(context, config, registerValidator, roleValidator);
userService.Register(user);
var addedUser = context.Users.Last();
movieService.Create(movie, addedUser);
MoviePostModel movie2 = new MoviePostModel
{
Title = "movie2",
Description = "description",
Duration = 120,
Year = 2018,
Director = "Alina",
Date = DateTime.Now,
Rating = 9,
Watched = "yes"
};
movieService.Create(movie2, addedUser);
int movies = movieService.GetAll(1).Entries.Count();
Assert.AreEqual(2, movies);
}
}
public void GetAllShouldReturnCorrectNumberOfPagesForMovies()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPagesForMovies))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var added = movieService.Create(new WebApplication3.ViewModels.MoviePostModel
{
Title = "Tianic",
Duration = 100,
Genre = "Thriller",
WatchedState = "Yes",
DateAdded = DateTime.Parse("2019-06-15T00:00:00"),
DateClosed = null,
//Title = movie.Title,
//Duration = movie.Duration,
//Genre = genre,
//WatchedState = watchedState,
//DateAdded = movie.DateAdded,
//DateClosed = movie.DateClosed,
//Comments = movie.Comments
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "A nice movie",
}
},
}, null);
DateTime from = DateTime.Parse("2019-06-13T00:00:00");
DateTime to = DateTime.Parse("2019-06-19T00:00:00");
var allTasks = movieService.GetAll(1, from, to);
Assert.AreEqual(1, allTasks.Entries.Count);
Assert.IsNotNull(allTasks);
}
}
public async Task <IActionResult> Create(Movie movie, IFormFile image)
{
// If image uploaded, make image name unique and store into "\wwwroot\images" folder,
// otherwise set validation error message
if (image != null && image.Length > 0)
{
string uniqueImageName = Guid.NewGuid().ToString() + "_" + image.FileName;
string imageFullPath = System.IO.Directory.GetCurrentDirectory() + @"\wwwroot\images\" + uniqueImageName;
using (var stream = System.IO.File.Create(imageFullPath))
{
await image.CopyToAsync(stream);
}
movie.ImagePath = uniqueImageName;
}
else
{
ModelState.AddModelError("Movie.ImagePath", "Please upload image");
}
// Check if has any validation error
if (!ModelState.IsValid)
{
var viewModel = new MovieFormViewModel
{
Genre = _genreService.GetFirst(),
Movie = new Movie()
};
return(View("CreateForm", viewModel));
}
movie.Rating = Array.Empty <int>();
movie.UsersThatRatedMovie = Array.Empty <string>();
_movieService.Create(movie);
return(RedirectToAction("Index", "Movies"));
}
public void UpsertShouldUpdateMovie()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(UpsertShouldUpdateMovie))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var userService = new UserService(context, config, registerValidator, roleValidator);
userService.Register(user);
var addedUser = context.Users.Last();
movieService.Create(movie, addedUser);
var addedMovie = context.Movies.Last();
context.Entry(addedMovie).State = EntityState.Detached;
int id = addedMovie.Id;
Movie movieToBeUpdated = new Movie
{
Title = "newMovie",
Description = "description",
Duration = 120,
Year = 2018,
Director = "Alina",
Date = DateTime.Now,
Rating = 9,
Watched = "no"
};
Movie updatedMovie = movieService.Upsert(id, movieToBeUpdated);
Assert.AreEqual(updatedMovie.Title, "newMovie");
}
}
public void GetByIdShouldReturnTaskWithCorrectId()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetByIdShouldReturnTaskWithCorrectId))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var added = new MoviePostModel()
{
Title = "Titanic",
Duration = 100,
Genre = "Thriller",
WatchedState = "Yes",
DateAdded = DateTime.Parse("2019-06-15T00:00:00"),
DateClosed = null,
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "A nice movie",
}
},
};
var current = movieService.Create(added, null);
var expected = movieService.GetById(current.Id);
Assert.IsNotNull(expected);
Assert.AreEqual(expected.Title, current.Title);
Assert.AreEqual(expected.Duration, current.Duration);
Assert.AreEqual(expected.WatchedState, current.WatchedState);
Assert.AreEqual(expected.Genre, current.Genre);
Assert.AreEqual(expected.Id, current.Id);
}
}
public void DeleteMovieWithCommentsShouldDeleteMoviesAndComments()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(DeleteMovieWithCommentsShouldDeleteMoviesAndComments))
.Options;
using (var context = new MoviesDbContext(options))
{
var moviesService = new MovieService(context);
var expected = new MoviePostModel()
{
Title = "Titanic",
Duration = 100,
Genre = "Thriller",
WatchedState = "Yes",
DateAdded = DateTime.Parse("2019-06-15T00:00:00"),
DateClosed = null,
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "A nice movie",
}
},
};
var actual = moviesService.Create(expected, null);
var afterDelete = moviesService.Delete(actual.Id);
int numberOfCommentsInDb = context.Comments.CountAsync().Result;
var resultExpense = context.Movies.Find(actual.Id);
Assert.IsNotNull(afterDelete);
Assert.IsNull(resultExpense);
Assert.AreEqual(0, numberOfCommentsInDb);
}
}
static void Main(string[] args)
{
var movieService = new MovieService();
// Creating movies
var newMovies = new List <Movie> {
new Movie("Olympus", "Fantasy movie about Olympus the Great City"),
new Movie("Prometheus", "Movie about He who stole fire from the Gods"),
new Movie("Thor", "Thor with his Hammer,smashing Good Guys "),
new Movie("Valhalla", "Acient Greek sci fi movie"),
};
newMovies.ForEach(movie =>
{
movieService.Create(movie);
});
// Fecth All movies in Database
var movies = movieService.GetAll();
DisplayMovies(movies);
//Updating a movie
var movieUpdate = movieService.Get(1);
movieUpdate.Title = "Updated Movie";
movieUpdate.Description = "Updated Movie Description";
movieService.Update(1, movieUpdate);
DisplayMovies(movies);
//Deleting a movie
movieService.Delete(1);
DisplayMovies(movies);
}
public void GetAllShouldReturnCorrectNumberOfPagesForComments()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnCorrectNumberOfPagesForComments))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var commentService = new CommentService(context);
var added = new MoviePostModel()
{
Title = "Tianic",
Duration = 100,
Genre = "Thriller",
WatchedState = "Yes",
DateAdded = DateTime.Parse("2019-06-15T00:00:00"),
DateClosed = null,
Comments = new List <Comment>()
{
new Comment
{
Important = true,
Text = "A nice movie",
Owner = null
}
},
};
var current = movieService.Create(added, null);
var allComments = commentService.GetAll(string.Empty, 1);
//var allComments = commentService.GetAll(string.Empty, 1);
Assert.AreEqual(1, allComments.NumberOfPages);
}
}
public void MovieCreateTest()
{
var options = new DbContextOptionsBuilder <MusicSpotDbContext>().UseInMemoryDatabase("MovieCreateCorrect").Options;
var dbContext = new MusicSpotDbContext(options);
var service = new MovieService(dbContext);
var movie = new Movie
{
Title = "Speed",
Genre = "Action",
ImageUrl = "aaa",
Year = 1998,
Description = "some description",
UserId = "aaa"
};
var result = service.Create(movie.Title, movie.Genre, movie.ImageUrl, movie.Year, movie.Description, movie.UserId);
Assert.That(result, Is.Not.Null);
Assert.AreEqual("Speed", movie.Title);
Assert.AreEqual(1, result);
Assert.That(movie.Id, Is.Not.Null);
}
public void GetAllShouldReturnAllMoviesWithPagination()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllMoviesWithPagination))
.Options;
using (var context = new MoviesDbContext(options))
{
var movieService = new MovieService(context);
var userService = new UserService(context, config, registerValidator, roleValidator);
userService.Register(user);
var addedUser = context.Users.Last();
movieService.Create(movie, addedUser);
var addedMovie = context.Movies.Last();
var allMovies = movieService.GetAll(1);
Assert.AreEqual(1, allMovies.NumberOfPages);
}
}
public IActionResult Create(MovieForm mf)
{
_service.Create(mf.toLocal());
return(RedirectToAction("Index"));
}
public ActionResult <Movie> Create(Movie movie)
{
_movieService.Create(movie);
return(CreatedAtRoute("GetMovie", new { id = movie.Id.ToString() }, movie));
}
public IActionResult MovieResult(string imdbId)
{
WebRequest request;
HttpWebResponse response;
string result = null;
string api = "api_key=8d8ebd7ef7cb1361e624639ac8fea328";
string finalResponse = "";
string getImdbIdUrl = String.Format("https://api.themoviedb.org/3/find/" + imdbId + "?" + api + "&external_source=imdb_id");
request = WebRequest.Create(getImdbIdUrl);
request.Method = "GET";
response = (HttpWebResponse)request.GetResponse();
using (Stream streamImdb = response.GetResponseStream())
{
StreamReader streamReaderImdb = new StreamReader(streamImdb);
result = streamReaderImdb.ReadToEnd();
streamReaderImdb.Close();
}
ImdbMovieResult imdbMovieResult = JsonConvert.DeserializeObject <ImdbMovieResult>(result);
int tmdbId = imdbMovieResult.movie_results.FirstOrDefault().id;
bool isThereAnyMovie = _movieService.IsItExistsByTmdbId(tmdbId);
if (isThereAnyMovie)
{
finalResponse += "This movie already exists in the Database!";
}
else
{
string getTmdbIdUrl = String.Format("https://api.themoviedb.org/3/movie/" + tmdbId + "?" + api + "&language=en-US");
request = WebRequest.Create(getTmdbIdUrl);
response = (HttpWebResponse)request.GetResponse();
using (Stream streamTmdb = response.GetResponseStream())
{
StreamReader streamReaderTmdb = new StreamReader(streamTmdb);
result = streamReaderTmdb.ReadToEnd();
streamReaderTmdb.Close();
}
TmdbMovieResult tmdbMovieResult = JsonConvert.DeserializeObject <TmdbMovieResult>(result);
bool isMovieCreated = _movieService.Create(tmdbMovieResult);
if (isMovieCreated)
{
finalResponse += "Movie were inserted into the Database!";
}
else
{
finalResponse += "Some error!";
}
}
bool isThereAnyCredits = _creditService.IsItExistsByTmdbId(tmdbId);
if (isThereAnyCredits)
{
finalResponse += "\nThese credits already exists in the Database!";
}
else
{
string getCreditsIdUrl = String.Format("https://api.themoviedb.org/3/movie/" + tmdbId + "/credits?" + api);
request = WebRequest.Create(getCreditsIdUrl);
response = (HttpWebResponse)request.GetResponse();
using (Stream streamCredits = response.GetResponseStream())
{
StreamReader streamReaderCredits = new StreamReader(streamCredits);
result = streamReaderCredits.ReadToEnd();
streamReaderCredits.Close();
}
MovieCredits movieCredits = JsonConvert.DeserializeObject <MovieCredits>(result);
bool isCreditsCreated = _creditService.Create(movieCredits);
if (isCreditsCreated)
{
finalResponse += "Credites were inserted into the Database!";
}
else
{
finalResponse += "Some error!";
}
//int counter = 0;
//foreach (var cast in movieCredits.cast)
//{
// bool isThereAnyPersonImegas = _personImagesService.IsItExistsByPersonId(cast.id);
// if (isThereAnyPersonImegas)
// continue;
// else
// counter++;
// string getPersonImageIdUrl = String.Format("https://api.themoviedb.org/3/person/" + cast.id + "/images?" + api);
// request = WebRequest.Create(getPersonImageIdUrl);
// response = (HttpWebResponse)request.GetResponse();
// using (Stream streamPersonImages = response.GetResponseStream())
// {
// StreamReader streamReaderPersonImages = new StreamReader(streamPersonImages);
// result = streamReaderPersonImages.ReadToEnd();
// streamReaderPersonImages.Close();
// }
// PersonImages personImages = JsonConvert.DeserializeObject<PersonImages>(result);
// var orderedPersonImages = personImages.profiles.OrderByDescending(x => x.vote_average).ToList();
// personImages.profiles = orderedPersonImages;
// personImages.id = cast.id;
// bool isPersonImagesCreated = _personImagesService.Create(personImages);
//}
int personDetailsCounter = 0;
foreach (var cast in movieCredits.cast)
{
bool isThereAnyPersonDetails = _personService.IsItExistsByPersonId(cast.id);
if (isThereAnyPersonDetails)
{
continue;
}
else
{
personDetailsCounter++;
}
string getPersonDetailsIdUrl = String.Format("https://api.themoviedb.org/3/person/" + cast.id + "?" + api + "&language=en-US");
request = WebRequest.Create(getPersonDetailsIdUrl);
response = (HttpWebResponse)request.GetResponse();
using (Stream streamPersonDetails = response.GetResponseStream())
{
StreamReader streamReaderPersonDetails = new StreamReader(streamPersonDetails);
result = streamReaderPersonDetails.ReadToEnd();
streamReaderPersonDetails.Close();
}
PersonDetails personDetails = JsonConvert.DeserializeObject <PersonDetails>(result);
bool isPersonImagesCreated = _personService.Create(personDetails);
}
finalResponse += "\n" + personDetailsCounter + " actor profiles were inserted into the Database!";
}
return(Ok(JsonConvert.SerializeObject(finalResponse)));
}
