public async Task Should_have_zero_movie_when_movie_deleted()
{
_dataBaseOptions = new DbContextOptionsBuilder <MovieContext>()
.UseInMemoryDatabase(databaseName: "databaseTest3")
.Options;
await using (var context = new MovieContext(_dataBaseOptions))
{
var service = new MovieService(context);
await service.Add(new Movie { Name = "Casablanca" });
context.SaveChanges();
}
await using (var context = new MovieContext(_dataBaseOptions))
{
var service = new MovieService(context);
var movieToDelete = (await service.Find("Casablanca")).FirstOrDefault();
await service.Delete(movieToDelete?.MovieId);
}
await using (var context = new MovieContext(_dataBaseOptions))
{
Assert.Equal(0, context.Movies.Count());
}
}
public IHttpActionResult Post([FromBody] MovieCreateDto movie)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Movie newMovie = new Movie
{
DirectorID = movie.DirectorID,
Title = movie.Title,
GenreID = movie.GenreID,
Description = movie.Description,
ReleaseDate = movie.ReleaseDate
};
movieService.Add(newMovie);
movieService.Save();
var dtoMovie = new MovieDto(newMovie);
return(Ok(dtoMovie));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
private bool AddMovie()
{
var movie = new MovieDto();
FillDataFromFields(movie, true);
return(_movieService.Add(movie, out _));
}
private void button1_Click(object sender, EventArgs e)
{
try
{
if (string.IsNullOrWhiteSpace(tbName.Text) || cbProductionYear.SelectedIndex == 0 || lbDirectors.SelectedItems.Count == 0)
{
MessageBox.Show("Fields cannot be empty!");
return;
}
MovieModel addMovieModel = new MovieModel();
addMovieModel.Name = tbName.Text.Trim();
addMovieModel.ProductionYear = cbProductionYear.Text;
addMovieModel.BoxOfficeReturn = null;
if (!string.IsNullOrWhiteSpace(tbBoxOffice.Text))
{
addMovieModel.BoxOfficeReturn = Convert.ToDouble(tbBoxOffice.Text.Trim().Replace(",", "."), CultureInfo.InvariantCulture);
}
addMovieModel.DirectorIds = new List <int>();
foreach (var selectedItem in lbDirectors.SelectedItems)
{
var directorModel = selectedItem as DirectorModel;
// var directorModel = (DirectorModel)selectedItem; 2.YOL
addMovieModel.DirectorIds.Add(directorModel.Id);
}
movieService.Add(addMovieModel);
MessageBox.Show("Movie saved!");
}
catch (Exception exc)
{
MessageBox.Show("An error occured!");
}
}
public async Task AddToDatabase_WhenCorrectParametersArePassed()
{
string title = "DieHard1";
DateTime releaseDate = DateTime.Now.AddYears(1);
decimal price = 220m;
string Genre = "Action";
var options = new DbContextOptionsBuilder <MovieSystemDbContext>()
.UseInMemoryDatabase(databaseName: "AddToDatabase_WhenCorrectParametersArePassed")
.Options;
var pageSortMock = new Mock <IPageSort>();
using (var context = new MovieSystemDbContext(options))
{
var service = new MovieService(context, pageSortMock.Object);
await service.Add(title, releaseDate, price, Genre);
var currentMovie = await context.Movies.ToListAsync();
Assert.AreEqual(1, currentMovie.Count);
Assert.AreEqual(title, currentMovie[0].Title);
Assert.AreEqual(releaseDate, currentMovie[0].ReleaseDate);
Assert.AreEqual(price, currentMovie[0].Price);
Assert.AreEqual(Genre, currentMovie[0].Genre);
}
}
private void btnSave_Click(object sender, EventArgs e)
{
using (MovieService movieService = new MovieService())
{
DialogResult dr = MessageBox.Show("Kaydetmek istediğinize emin misiniz?", "Onay", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (dr == DialogResult.Yes)
{
MovieDTO movie = new MovieDTO
{
MovieName = txtMovieName.Text,
GenreId = Convert.ToByte(cmbGenre.SelectedValue),
DirectorName = txtDirector.Text,
ActorList = actorsList,
ReleaseDate = dtpRelease.Value,
ImdbScore = Convert.ToByte(txtImdb.Text),
Quantity = Convert.ToInt32(txtQuantity.Text),
UnitPrice = Convert.ToDecimal(txtPrice.Text),
CreatedBy = 2
};
var result = movieService.Add(movie);
if (result != null)
{
MessageBox.Show("Kayıt başarılı", "Durum", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("Kayıt sırasında bir hata oluştu", "Hata", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
}
public void Save()
{
MovieDTO movie = new MovieDTO
{
MovieName = "organize işler",
GenreId = 2,
DirectorName = "yılmaz erdoğan",
ReleaseDate = new DateTime(2019, 3, 1),
ImdbScore = 6,
Quantity = 50,
UnitPrice = 20,
RecordStatusId = 1,
CreatedDate = DateTime.Now,
CreatedBy = 2
};
movie.ActorList = new System.Collections.Generic.List <MovieActorDTO>();
MovieActorDTO actor1 = new MovieActorDTO
{
FullName = "kıvanç tatlıtuğ"
};
MovieActorDTO actor2 = new MovieActorDTO
{
FullName = "yılmaz erdoğan"
};
movie.ActorList.Add(actor1);
movie.ActorList.Add(actor2);
var result = movieService.Add(movie);
Assert.IsNotNull(result);
}
private async void SaveMovie(object movieObject)
{
Movie movie = movieObject as Movie;
if (movie != null)
{
IsBusy = true;
if (movie.Id > 0)
{
Movie updatedMovie = await movieService.Update(movie);
if (updatedMovie != null)
{
int pos = Movies.IndexOf(updatedMovie);
Movies.RemoveAt(pos);
Movies.Insert(pos, updatedMovie);
}
}
else
{
Movie addedMovie = await movieService.Add(movie);
if (addedMovie != null)
{
Movies.Add(addedMovie);
}
}
IsBusy = false;
}
Back();
}
public async Task Should_update_the_movie_when_the_name_was_modified()
{
_dataBaseOptions = new DbContextOptionsBuilder <MovieContext>()
.UseInMemoryDatabase(databaseName: "databaseTest2")
.Options;
await using (var context = new MovieContext(_dataBaseOptions))
{
var service = new MovieService(context);
await service.Add(new Movie { Name = "Casablanca" });
context.SaveChanges();
}
await using (var context = new MovieContext(_dataBaseOptions))
{
var service = new MovieService(context);
var movieToUpdate = (await service.Find("Casablanca")).FirstOrDefault();
movieToUpdate.Name = "Titanic";
await service.Update(movieToUpdate);
}
await using (var context = new MovieContext(_dataBaseOptions))
{
Assert.Equal(1, context.Movies.Count());
Assert.Equal("Titanic", context.Movies.Single().Name);
}
}
public IActionResult AddMovie(string movieUrl, string movieName)
{
movieService.Add(new Movie()
{
Name = movieName, Path = movieUrl
});
return(RedirectToAction("Index"));
}
public async Task <IActionResult> AddMovie(Movie movie)
{
if (!ModelState.IsValid)
{
return(View(movie));
}
await _movieService.Add(movie);
return(RedirectToAction("Index"));
}
public IHttpActionResult AddMovie([FromBody] Movie movie)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_movieService.Add(movie);
return(Ok("added"));
}
public async Task MovieService_AddMovie_Should_Be_Ok()
{
var fakeMovie = new Movie();
int newId = 2;
movieRepositoryMock.Setup(m => m.Add(fakeMovie)).Returns(Task.FromResult(newId));
var insertedId = await movieService.Add(fakeMovie);
insertedId.Should().Be(newId);
movieRepositoryMock.Verify(m => m.Add(fakeMovie), Times.Once);
movieRepositoryMock.VerifyNoOtherCalls();
}
public void GivenMovieWithSameTitle_WhenAddingNewMovie_ThenMovieFromRepository()
{
var mock = new Mock <IMovieRepository>();
var movie = new Movie()
{
Title = "test film", Description = "description"
};
mock.Setup(p => p.GetByTitle(It.IsAny <string>()))
.Returns(movie);
mock.Setup(p => p.Add(It.IsAny <Movie>()))
.Returns(movie);
var service = new MovieService(mock.Object);
var dbMovie = service.Add(movie);
Assert.IsNull(dbMovie);
}
public async Task <IActionResult> Create(MovieModel movie)
{
if (ModelState.IsValid)
{
if ((await _context.IsTitleDuplicate(movie.Title)))
{
TempData["ErrorMessage"] = "Title was duplicated !";
return(View(movie));
}
movie.UserCreated = HttpContext.Session.GetString(Constants.SESSION_KEY_LOGIN_SYSTEM_ADMIN_ID);
movie.DateCreated = DateTime.Now;
await _context.Add(movie);
return(RedirectToAction("Index"));
}
return(View(movie));
}
public IActionResult Add(MovieViewModel model)
{
if (ModelState.IsValid == false)
{
SelectListItem[] categoryList = new SelectListItem[]
{
new SelectListItem()
{
Text = "Seçiniz"
},
new SelectListItem()
{
Text = "Dram", Value = "Drama"
},
new SelectListItem()
{
Text = "Macera", Value = "Adventure"
},
new SelectListItem()
{
Text = "Biyografi", Value = "Biography"
}
};
model.CategorySelectList = categoryList;
return(View(model));
}
MovieEntity entity = new MovieEntity()
{
Id = model.Id,
Name = model.Name,
Director = model.Director,
Cast = model.Cast,
ReleaseYear = model.ReleaseYear,
Writer = model.Writer,
Category = model.Category,
ImdbUrl = model.ImdbUrl,
Score = model.Score,
Review = model.Review
};
_movieService.Add(entity);
return(RedirectToAction(nameof(Index), "Movie"));
}
public ActionResult Insert(Movie item, HttpPostedFileBase fluAfis)
{
ViewBag.CategoryID = new SelectList(cs.GetActive(), "ID", "CategoryName");
User u = (User)Session["oturum"];
item.UserID = u.ID;
try
{
using (TransactionScope ts = new TransactionScope())
{
if (ModelState.IsValid)
{
bool islemSonucu;
string info = FxFunction.ImageUpload(fluAfis, Path.Posters, out islemSonucu);
if (islemSonucu)
{
item.PosterPath = info;
bool sonuc = ms.Add(item);
ts.Complete();
return(RedirectToAction("Index"));
}
else
{
ViewBag.Message = $"Resim yükleme işlemi sırasında bir hata oluştu. {info}";
}
}
else
{
ViewBag.Message = $"Lütfen kayıt işlemi yapmak için tüm alanların uygun şekilde doldurulduğundan emin olun.";
}
}
}
catch (Exception ex)
{
ViewBag.Message = $"İşlem sırasında bir hata oluştu. Sorunun devam etmesi durumunda lütfen sistem yöneticinize başvurun. {ex.Message} - Hata Tarihi : {DateTime.Now.ToString()}";
}
return(View(item));
}
public async Task Should_have_on_movie_on_the_list_when_movie_was_add()
{
_dataBaseOptions = new DbContextOptionsBuilder <MovieContext>()
.UseInMemoryDatabase(databaseName: "databaseTest")
.Options;
await using (var context = new MovieContext(_dataBaseOptions))
{
var service = new MovieService(context);
await service.Add(new Movie { Name = "Casablanca" });
context.SaveChanges();
}
await using (var context = new MovieContext(_dataBaseOptions))
{
Assert.Equal(1, context.Movies.Count());
Assert.Equal("Casablanca", context.Movies.Single().Name);
}
}
public void Save()
{
try
{
var IsSaved = ObjMovieService.Add(CurrentMovie);
LoadData();
if (IsSaved)
{
Message = "Employee saved";
}
else
{
Message = "Save operation failed";
}
}
catch (Exception ex)
{
Message = ex.Message;
}
}
public ActionResult Create(MovieFormViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Genres = _genreService.GetAll().ToList();
return(View("Create", viewModel));
}
var movie = new Movie
{
Name = viewModel.Name,
Director = viewModel.Director,
GenreId = viewModel.Genre,
Description = viewModel.Description,
ReleaseDate = viewModel.GetDateTime()
};
_movieService.Add(movie);
_movieService.Save();
return(RedirectToAction("Index", "Home"));
}
public ActionResult Create(string Name, double?BoxOfficeReturn, string ProductionYear, List <int> DirectorIds)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction("Login", "Account"));
}
if (!User.IsInRole("Admin"))
{
return(RedirectToAction("Login", "Account"));
}
try
{
if (string.IsNullOrWhiteSpace(Name))
{
return(Content("Name must not be empty."));
}
if (Name.Length > 250)
{
return(Content("Name must have maximum 250 characters."));
}
MovieModel model = new MovieModel()
{
Name = Name,
BoxOfficeReturn = BoxOfficeReturn,
ProductionYear = ProductionYear,
DirectorIds = DirectorIds
};
_movieService.Add(model);
//return RedirectToAction("List", "Movies");
return(RedirectToAction("List"));
}
catch (Exception exc)
{
return(View("Exception"));
}
}
public IActionResult Add(AddMovieViewModel viewModel)
{
movieService.Add(viewModel.Title, viewModel.Star, viewModel.ReleaseDate);
return(RedirectToAction("Index"));
}
public IHttpActionResult AddMovie([FromBody] MovieRequest movie)
{
_movieService.Add(movie);
return(Ok("added"));
}
public void AddMovie([FromBody] Movie movie)
{
_movieService.Add(movie);
}
public IActionResult CreateMovie(Movies movies)
{
movies.Rating = Convert.ToDouble(movies.Rating);
_movieService.Add(movies);
return(RedirectToAction("Index"));
}
