public async Task <ActionResult <MovieDirectorDTO> > PostMovieDirector(int movieId, int directorId)
{
try
{
var movie = await _movieDirectorsRepository.GetMovieById(movieId);
var director = await _movieDirectorsRepository.GetDirectorById(directorId);
if (movie == null)
{
return(BadRequest($"Unable to find movie with Id: {movieId}"));
}
else if (director == null)
{
return(BadRequest($"Unable to find director with Id: {directorId}"));
}
var movieDirector = new MovieDirector {
Movie = movie, Director = director
};
_movieDirectorsRepository.Add(movieDirector);
if (await _movieDirectorsRepository.Save())
{
return(Created($"/api/v1.0/MovieDirectors/{movieDirector.MovieDirectorID}", _mapper.Map <MovieDirectorDTO>(movieDirector)));
}
}
catch (Exception e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"Database Failure: {e.Message}"));
}
return(BadRequest());
}
public bool UpdateMovie(List <int> directorId, List <int> categoryId, Movie movie)
{
var directors = _movieContext.Directors.Where(d => directorId.Contains(d.Id)).ToList();
var categories = _movieContext.Categories.Where(c => categoryId.Contains(c.Id)).ToList();
var deleteMovieDirector = _movieContext.MovieDirectors.Where(md => md.MovieId == movie.Id);
var deleteMovieCategory = _movieContext.MovieCategories.Where(mc => mc.MovieId == movie.Id);
_movieContext.RemoveRange(deleteMovieDirector);
_movieContext.RemoveRange(deleteMovieCategory);
foreach (var director in directors)
{
var movieDirector = new MovieDirector()
{
Movie = movie,
Director = director
};
_movieContext.Add(movieDirector);
}
foreach (var category in categories)
{
var movieCategory = new MovieCategory()
{
Movie = movie,
Category = category
};
_movieContext.Add(movieCategory);
}
_movieContext.Update(movie);
return(Save());
}
//need Lis<int> as a paarameted as these list of ids coming from Uri
public bool CreateMovie(List <int> directorId, List <int> categoryId, Movie movie)
{
//Movie enittiy model also has reeference to director & category model
var directors = _movieContext.Directors.Where(d => directorId.Contains(d.Id)).ToList();
var categories = _movieContext.Categories.Where(c => categoryId.Contains(c.Id)).ToList();
foreach (var director in directors)
{
var movieDirector = new MovieDirector()
{
Movie = movie,
Director = director
};
_movieContext.Add(movieDirector);
}
foreach (var category in categories)
{
var movieCategory = new MovieCategory()
{
Movie = movie,
Category = category
};
_movieContext.Add(movieCategory);
}
_movieContext.Add(movie);
return(Save());
}
public bool AddToMovieDirector(string imdbId, string directors)
{
try
{
MovieDirector movieDirectorExisting = _context.MovieDirector.Where(md => md.Imdbid == imdbId).FirstOrDefault();
if (movieDirectorExisting == null)
{
string[] directorArray = SplitString(directors);
for (int i = 0; i < directorArray.Length; i++)
{
// Create a new MovieDirector object and fill in the details
MovieDirector newEntry = new MovieDirector();
newEntry.Imdbid = imdbId;
newEntry.Director = directorArray[i].Trim();
if (ModelState.IsValid)
{
//Add the new MovieDirector to the table
_context.MovieDirector.Add(newEntry);
_context.SaveChanges();
}
}
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public async Task UpdateMovie_ShoulAddSecondMovieDirector_WhenOtherExistsPreviously()
{
var movieUnderTest = TestMovieSeededWithRelatedInfo;
var secondRelationUnderTest = new MovieDirector
{
Movie = movieUnderTest,
MovieId = movieUnderTest.Id,
Person = TestDirectorNotSeeded,
PersonId = TestDirectorNotSeeded.Id
};
using var context = DbContextScopeFactory.Create();
movieUnderTest.DirectorList.Add(secondRelationUnderTest);
await MovieDetailsDbAccess.UpdateMovie(Mapper.Map <UpdateMovieDetailsDto>(movieUnderTest));
context.SaveChanges();
var existingFirstRelation = MoviesContext.MovieDirectors.Find(movieUnderTest.Id, TestDirectorSeeded.Id);
var existingSecondRelation = MoviesContext.MovieDirectors.Find(movieUnderTest.Id, TestDirectorNotSeeded.Id);
var existingSecondPerson = MoviesContext.People.Find(TestDirectorNotSeeded.Id);
var existingMovie = MoviesContext.Movies.Find(movieUnderTest.Id);
existingFirstRelation.Should().BeEquivalentTo(TestMovieDirectorSeeded);
existingSecondRelation.Should().BeEquivalentTo(secondRelationUnderTest);
existingSecondPerson.Should().Be(TestDirectorNotSeeded);
existingMovie.Should().Be(movieUnderTest);
}
public void Update(MovieModel model)
{
try
{
Movie entity = db.Movies.Find(model.Id);
entity.Name = model.Name;
entity.BoxOfficeReturn = model.BoxOfficeReturn;
entity.ProductionYear = model.ProductionYear;
entity.MovieDirectors = new List <MovieDirector>();
MovieDirector movieDirector;
foreach (int directorId in model.DirectorIds)
{
movieDirector = new MovieDirector()
{
MovieId = entity.Id,
DirectorId = directorId
};
entity.MovieDirectors.Add(movieDirector);
}
db.Entry(entity).State = EntityState.Modified;
db.SaveChanges();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Assigns an Director to a Movie in the database.
/// Adds the Director to the database if it does not exist.
/// Returns true if successful.
/// </summary>
/// <param name="movieDirectorName"></param>
/// <returns></returns>
public bool AddMovieDirector(string movieId, string movieDirectorName)
{
if (!MovieExists(movieId))
{
return(false);
}
if (!DirectorExists(movieDirectorName))
{
Director newDirector = new Director();
newDirector.DirectorName = movieDirectorName;
AddDirector(newDirector);
}
Director director = GetDirector(movieDirectorName);
if (director == null)
{
return(false);
}
MovieDirector movieDirector = new MovieDirector();
movieDirector.ImdbId = movieId;
movieDirector.DirectorId = director.DirectorId;
_dbContext.MovieDirectors.Add(movieDirector);
_dbContext.SaveChanges();
return(true);
}
public ActionResult Edit([Bind(Include = "Id, Name, ProductionYear")] Movie movie, string BoxOfficeReturn, List <int> directorIds)
{
var entity = db.Movies.SingleOrDefault(e => e.Id == movie.Id);
entity.Name = movie.Name;
entity.ProductionYear = movie.ProductionYear;
entity.BoxOfficeReturn = Convert.ToDouble(BoxOfficeReturn.Replace(",", "."), CultureInfo.InvariantCulture);
entity.MovieDirectors = new List <MovieDirector>();
var movieDirectors = db.MovieDirectors.Where(e => e.MovieId == movie.Id).ToList();
foreach (var movieDirector in movieDirectors)
{
db.MovieDirectors.Remove(movieDirector);
}
foreach (var directorId in directorIds)
{
var movieDirector = new MovieDirector()
{
MovieId = movie.Id,
DirectorId = directorId
};
entity.MovieDirectors.Add(movieDirector);
}
db.Entry(entity).State = EntityState.Modified;
db.SaveChanges();
TempData["Info"] = "Record successfully updated in database.";
return(RedirectToRoute(new { controller = "Movies", action = "Index" }));
}
public void TestAddMovieDirector()
{
var sut = new MovieDirector()
{
ImdbId = "12345",
DirectorId = Guid.NewGuid(),
Director = new Director()
{
DirectorId = Guid.NewGuid(), DirectorName = "Anis"
},
Imdb = new Movie()
{
ImdbId = "12345", Title = "Titanic"
}
};
bool result;
using (var context2 = new Cinephiliacs_MovieContext(dbOptions))
{
context2.Database.EnsureCreated();
var msr = new RepoLogic(context2);
result = msr.AddMovieActor(sut.Imdb.ImdbId, sut.Director.DirectorName);
}
Assert.False(result);
}
public async Task UpdateMovie_ShouldAddDirectorAndMovieDirector_WhenDirectorNotExists()
{
using var context = DbContextScopeFactory.Create();
var movieUnderTest = TestMovieSeededWithoutRelatedInfo;
var relationUnderTest = new MovieDirector
{
Movie = movieUnderTest,
MovieId = movieUnderTest.Id,
Person = TestDirectorNotSeeded,
PersonId = TestDirectorNotSeeded.Id
};
movieUnderTest.DirectorList.Add(relationUnderTest);
await MovieDetailsDbAccess.UpdateMovie(Mapper.Map <UpdateMovieDetailsDto>(movieUnderTest));
context.SaveChanges();
var existingMovie = MoviesContext.Movies.Find(movieUnderTest.Id);
var existingRelation = MoviesContext.MovieDirectors.Find(movieUnderTest.Id, TestDirectorNotSeeded.Id);
var existingDirector = MoviesContext.People.Find(TestDirectorNotSeeded.Id);
existingMovie.Should().Be(movieUnderTest);
existingRelation.Should().BeEquivalentTo(relationUnderTest);
existingDirector.Should().Be(TestDirectorNotSeeded);
}
void ReleaseDesignerOutlets()
{
if (MovieDirector != null)
{
MovieDirector.Dispose();
MovieDirector = null;
}
if (MoviePicture != null)
{
MoviePicture.Dispose();
MoviePicture = null;
}
if (MovieSynopsis != null)
{
MovieSynopsis.Dispose();
MovieSynopsis = null;
}
if (MovieTitle != null)
{
MovieTitle.Dispose();
MovieTitle = null;
}
}
public async Task <IActionResult> Edit(int id, [Bind("movieId,directorId")] MovieDirector movieDirector)
{
if (id != movieDirector.movieId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movieDirector);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovieDirectorExists(movieDirector.movieId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["directorId"] = new SelectList(_context.Directors, "ID", "ID", movieDirector.directorId);
ViewData["movieId"] = new SelectList(_context.Movies, "ID", "ID", movieDirector.movieId);
return(View(movieDirector));
}
public bool AddDirector(int movieId, int personId)
{
var director = new MovieDirector {
MovieId = movieId, PersonId = personId
};
return(_repsitory.AddDirector(director));
}
public bool RemoveDirector([FromBody] MovieDirectorModel newDirectorModel)
{
var newDirector = new MovieDirector
{
MovieId = newDirectorModel.MovieId,
PersonId = newDirectorModel.PersonId
};
return(_repsitory.RemoveDirector(newDirector));
}
private void CreateTestManyToManyData()
{
TestMovieDirectorSeeded = new MovieDirector
{
Person = TestDirectorSeeded,
PersonId = TestDirectorSeeded.Id,
Movie = TestMovieSeededWithRelatedInfo,
MovieId = TestMovieSeededWithRelatedInfo.Id
};
TestMovieActorSeeded = new MovieActor
{
Person = TestActorSeeded,
PersonId = TestActorSeeded.Id,
Movie = TestMovieSeededWithRelatedInfo,
MovieId = TestMovieSeededWithRelatedInfo.Id,
AsCharacter = "Test"
};
TestMovieWriterSeeded = new MovieWriter
{
Person = TestWriterSeeded,
PersonId = TestWriterSeeded.Id,
Movie = TestMovieSeededWithRelatedInfo,
MovieId = TestMovieSeededWithRelatedInfo.Id,
};
TestMovieCompanySeeded = new MovieCompany
{
Company = TestCompanySeeded,
CompanyId = TestCompanySeeded.Id,
Movie = TestMovieSeededWithRelatedInfo,
MovieId = TestMovieSeededWithRelatedInfo.Id,
};
TestMovieImageSeeded = fixture.Build <MovieImageData>()
.With(x => x.Movie, TestMovieSeededWithRelatedInfo)
.With(x => x.MovieId, TestMovieSeededWithRelatedInfo.Id)
.Create();
TestMovieImageNotSeeded = fixture.Build <MovieImageData>()
.With(x => x.Movie, TestMovieNotSeeded)
.With(x => x.MovieId, TestMovieNotSeeded.Id)
.Create();
TestMovieSimilarSeeded = new MovieSimilar
{
Similar = TestMovieSeededWithoutRelatedInfo,
SimilarId = TestMovieSeededWithoutRelatedInfo.Id,
Movie = TestMovieSeededWithRelatedInfo,
MovieId = TestMovieSeededWithRelatedInfo.Id,
};
TestMovieSeededWithRelatedInfo.DirectorList.Add(TestMovieDirectorSeeded);
TestMovieSeededWithRelatedInfo.ActorList.Add(TestMovieActorSeeded);
TestMovieSeededWithRelatedInfo.WriterList.Add(TestMovieWriterSeeded);
TestMovieSeededWithRelatedInfo.CompanyList.Add(TestMovieCompanySeeded);
TestMovieSeededWithRelatedInfo.Images.Add(TestMovieImageSeeded);
TestMovieSeededWithRelatedInfo.Similars.Add(TestMovieSimilarSeeded);
}
public async Task <IActionResult> Create([Bind("movieId,directorId")] MovieDirector movieDirector)
{
if (ModelState.IsValid)
{
_context.Add(movieDirector);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["directorId"] = new SelectList(_context.Directors, "ID", "ID", movieDirector.directorId);
ViewData["movieId"] = new SelectList(_context.Movies, "ID", "ID", movieDirector.movieId);
return(View(movieDirector));
}
public ActionResult Edit([Bind(Include = "Id, Name, ProductionYear")] Movie movie, string BoxOfficeReturn, List <int> directorIds, HttpPostedFileBase Image)
{
string filePath = CreateFilePath(movie.Name, Image); // --
var entity = db.Movies.SingleOrDefault(e => e.Id == movie.Id);
string oldFilePath = entity.FilePath; // --
entity.Name = movie.Name;
entity.ProductionYear = movie.ProductionYear;
entity.BoxOfficeReturn = Convert.ToDouble(BoxOfficeReturn.Replace(",", "."), CultureInfo.InvariantCulture);
if (Image != null && Image.ContentLength > 0) // eğer gelen bir resim var güncelle
{
entity.FilePath = filePath;
}
entity.MovieDirectors = new List <MovieDirector>();
var movieDirectors = db.MovieDirectors.Where(e => e.MovieId == movie.Id).ToList();
foreach (var movieDirector in movieDirectors)
{
db.MovieDirectors.Remove(movieDirector);
}
foreach (var directorId in directorIds)
{
var movieDirector = new MovieDirector()
{
MovieId = movie.Id,
DirectorId = directorId
};
entity.MovieDirectors.Add(movieDirector);
}
db.Entry(entity).State = EntityState.Modified;
db.SaveChanges();
if (filePath != null)
{
if (!String.IsNullOrWhiteSpace(oldFilePath)) // eski ımage ile ilgili kontrolleri yapıp sildik
{
if (System.IO.File.Exists(Server.MapPath("~/" + oldFilePath)))
{
System.IO.File.Delete(Server.MapPath("~/" + oldFilePath));
}
}
Image.SaveAs(Server.MapPath("~/" + filePath));
}
TempData["Info"] = "Record successfully updated in database.";
return(RedirectToRoute(new { controller = "Movies", action = "Index" }));
}
public ActionResult Edit([Bind(Include = "Id,Name,ProductionYear")] Movie movie, string BoxOfficeReturn, List <int> directorIds, HttpPostedFileBase Image) //public ActionResult Edit(Movie movie,string BoxOfficeReturn) - boxofficereturn virgülle girildigi zaman doublea çeviremedigi için null geliyor, string olarak ayrı alıp controllerda set edebiliriz bu şekilde
{
string filePath = CreateFilePath(Image, movie.Name);
var entity = db.Movies.SingleOrDefault(e => e.Id == movie.Id);
string oldFilePath = entity.FilePath;
entity.Name = movie.Name;
entity.ProductionYear = movie.ProductionYear;
entity.BoxOfficeReturn = Convert.ToDouble(BoxOfficeReturn.Replace(",", "."), CultureInfo.InvariantCulture);
entity.MovieDirectors = new List <MovieDirector>();
if (Image != null && Image.ContentLength > 0)
{
entity.FilePath = filePath;
}
var movieDirectors = db.MovieDirectors.Where(e => e.MovieId == movie.Id);
foreach (var movieDirector in movieDirectors)
{
db.MovieDirectors.Remove(movieDirector); // movienin yönetmenlerini sildik ara tabloyu bu moviele alakalı verileri boşalttık
}
foreach (var directorId in directorIds) // elimizdeki editlenecek yönetmenlerin idlerine göre her biri için movie director newleyerek entitymize ekleyip sonrasında entityi veritabanında güncelledik
{
var movieDirector = new MovieDirector()
{
MovieId = movie.Id,
DirectorId = directorId
};
entity.MovieDirectors.Add(movieDirector);
}
db.Entry(entity).State = EntityState.Modified;
db.SaveChanges();
if (filePath != null)
{
if (!String.IsNullOrWhiteSpace(oldFilePath))
{
if (System.IO.File.Exists(Server.MapPath("~/" + oldFilePath)))
{
System.IO.File.Delete(oldFilePath);
}
}
Image.SaveAs(Server.MapPath("~/" + filePath));
}
TempData["Info"] = "Record successfully updated in database.";
return(RedirectToRoute(new { controller = "Movies", action = "Index" }));
}
private void submit_Click(object sender, RoutedEventArgs e)
{
Movie submittedMovie = new Movie(MovieTitle.Text, MovieGenre.Text, Convert.ToDouble(MovieReviewScore.Text), MovieDirector.Text, Convert.ToInt32(MovieLegnth.Text), MovieamountOfWoollyBearLikeness.Text, MovieMoviePoster.Text);
MovieList.Add(submittedMovie);
//submittedMovie.Title = MovieTitle.Text;
//submittedMovie.Genre = MovieGenre.Text;
// submittedMovie.ReviewScore = Convert.ToDouble(MovieReviewScore.Text);
//submittedMovie.DisplayInformation();
MovieTitle.Clear();
MovieGenre.Clear();
MovieReviewScore.Clear();
MovieDirector.Clear();
MovieLegnth.Clear();
MovieamountOfWoollyBearLikeness.Clear();
MoviePoster.Clear();
}
public ActionResult Edit([Bind(Include = "Id, Name, ProductionYear")] Movie movie, string BoxOfficeReturn, List <int> directorIds)
{
var entity = db.Movies.SingleOrDefault(e => e.Id == movie.Id);
entity.Name = movie.Name;
entity.ProductionYear = movie.ProductionYear;
if (BoxOfficeReturn != "")
{
entity.BoxOfficeReturn = Convert.ToDouble(BoxOfficeReturn.Replace(",", "."), CultureInfo.InvariantCulture);
}
else
{
TempData["Info"] = "Adam gibi birşey gir";
return(RedirectToRoute(new { Controller = "Movies", action = "Edit" }));
}
entity.MovieDirectors = new List <MovieDirector>(); //yeni liste
var movieDirectors = db.MovieDirectors.Where(e => e.MovieId == movie.Id).ToList();
foreach (var movieDirector in movieDirectors)
{
//db.Entry(movieDirector).State = EntityState.Deleted; //önce eski kayıtları silmek gerekiyor.
db.MovieDirectors.Remove(movieDirector);
}
foreach (var directorId in directorIds)
{
var movieDirector = new MovieDirector()
{
MovieId = movie.Id,
DirectorId = directorId
};
entity.MovieDirectors.Add(movieDirector);
}
db.Entry(entity).State = EntityState.Modified;
db.SaveChanges();
TempData["Info"] = "Record successfully updated to database";
return(RedirectToRoute(new { Controller = "Movies", action = "Index" }));
}
public bool UpdateMovie(List <int> directorsId, List <int> categoriesId, Movie movie)
{
/*update method removes the association of movie to directors/categories from associative table first in order to add new association as update method is used to update the movie object
* and not associative table and thus idea is to delete that relationship first and add the newly updated relationship */
var directors = _movieContext.Directors.Where(d => directorsId.Contains(d.Id)).ToList();
var categories = _movieContext.Categories.Where(c => categoriesId.Contains(c.Id)).ToList();
var deleteMovieDirector = _movieContext.MovieDirectors.Where(md => md.MovieId == movie.Id);
var deleteMovieCategory = _movieContext.MovieCategories.Where(mc => mc.MovieId == movie.Id);
_movieContext.RemoveRange(deleteMovieDirector); //removes the existing relationship from MovieDirectors table of movie with director based on movieId
_movieContext.RemoveRange(deleteMovieCategory); //removes the existing relationship from MovieCategories table of movie with category based on movieId
foreach (var director in directors)
{
var movieDirector = new MovieDirector()
{
Movie = movie,
Director = director
};
_movieContext.Add(movieDirector);
}
foreach (var category in categories)
{
var movieCategory = new MovieCategory()
{
Movie = movie,
Category = category
};
_movieContext.Add(movieCategory);
}
_movieContext.Update(movie);
return(Save());
}
public IActionResult Create(MoviesModel model, string DirectorChoice)
{
List <Movie> li = db.Movies.ToList(); var item = li[li.Count - 1].MovieID;
Movie m = new Movie();
m.Title = model.Title;
m.Runtime = model.Runtime;
m.MovieID = item + 1;
db.Movies.Add(m);
db.SaveChanges();
int dID = Int32.Parse(DirectorChoice);
MovieDirector d = new MovieDirector();
d.MovieID = item + 1;
d.DirectorID = dID;
db.MovieDirectors.Add(d);
db.SaveChanges();
return(Index());
}
/// <summary>
/// File feltöltés
/// Csak csv-t fogad el
/// </summary>
///<returns></returns>
public async Task <ActionResult> UploadFileProcess(HttpPostedFileBase file)
{
// ha nem lett file kiválasztva
if (file == null)
{
return(RedirectToAction("UploadFile",
new { error = "No file found." }));
}
//Ha nem megfelelő a file végződés
if (!FILE_EXTENSIONS.Contains(file.FileName.Split('.').Last()))
{
return(RedirectToAction("UploadFile",
new { error = "The file extension is incorrect.\nCorrect file extensions: csv" }));
}
List <string> csvData = new List <string>();
using (StreamReader reader = new StreamReader(file.InputStream, Encoding.Default, true))
{
while (!reader.EndOfStream)
{
csvData.Add(reader.ReadLine());
}
}
for (int i = 0; i < csvData.Count; i++)
{
string line = csvData[i];
string[] datas = line.Split(';');
if (datas.Length != 5)
{
return(RedirectToAction("UploadFile",
new { error = "Incorrect file format. Line: " + (line + 1) + "\nCorrect file format: MovieTitle;MovieGenre;MoviePrice;DirectorName;PosterUrl\nEncoding:ANSI" }));
}
string title = datas[0];
string genre_in = datas[1];
MovieGenre genre = this.db.MovieGenres.FirstOrDefault(g => g.MovieGenreName == genre_in);
decimal price = Convert.ToDecimal(datas[2]);
string director_in = datas[3];
MovieDirector director = this.db.MovieDirectors.FirstOrDefault(d => d.MovieDirectorName == director_in);
string posterUrl = datas[4];
// a megadott director nincs benne az adatbázisban
if (director == null)
{
return(RedirectToAction("UploadFile",
new { error = "The given director: " + director_in + " cannot be found in the database" }));
}
if (genre == null)
{
return(RedirectToAction("UploadFile",
new { error = "The given genre: " + genre_in + " cannot be found in the database" }));
}
// ha az adott film már szerepel a listában, akkor csak átírjuk az adatait
Movie movie = this.db.Movies.FirstOrDefault(m => m.MovieTitle == title);
if (movie != null)
{
movie.MovieTitle = title;
movie.MovieGenre = genre;
movie.MoviePrice = price;
movie.MovieDirector = director;
movie.MoviePosterUrl = posterUrl;
}
// ha nem volt benne az adatbázisban
else
{
this.db.Movies.Add(new Movie()
{
MovieTitle = title,
MovieGenre = genre,
MoviePrice = price,
MovieDirector = director,
MoviePosterUrl = posterUrl
});
}
this.db.SaveChanges();
}
return(RedirectToAction("Index"));
}
static void Main(string[] args)
{
List<Movie> myMoviesList = new List<Movie>(); // list creation and definition
for (int i = 0; i < 5; i++)
{
Movie myMovie = new Movie(i);
Console.WriteLine("Please input movie name >");
String movieName = Console.ReadLine();
myMovie.SetMovieName(movieName);
Console.WriteLine("Please input movie type >");
String movieType = Console.ReadLine();
myMovie.SetMovieType(movieType);
Console.WriteLine("Please input movie lenght >");
int movieLength = int.Parse(Console.ReadLine());
myMovie.SetMovieLength(movieLength);
Console.WriteLine("Please input movie director >");
String movieDirector = Console.ReadLine();
MovieDirector md1 = new MovieDirector(movieDirector);
myMovie.SetMovieDirector(md1);
Console.WriteLine("Please input the number of actors>");
int numberActors = int.Parse(Console.ReadLine());
for (int j = 0; j < numberActors; j++)
{
Console.WriteLine("Please input actor name ");
string actorName = Console.ReadLine();
Console.WriteLine("Please input actor sur name ");
string actorSUrName = Console.ReadLine();
Console.WriteLine("Please input actor type ");
string actorType = Console.ReadLine();
int birthDay = int.Parse(Console.ReadLine());
Console.WriteLine("Please input bitrhday >");
MovieActor movieActor = new MovieActor(i, actorName, actorSUrName, birthDay, actorType);
myMovie.AddActor(movieActor);
}
myMoviesList.Add(myMovie);
}
// myMoviesList.Remove(movie1); // remove object from list
foreach (Movie movieTemp in myMoviesList) // pass over list
{
Console.WriteLine(movieTemp.ToString());
}
Console.ReadKey();
}
private void UpdateRelatedInfo(UpdateMovieDetailsDto movie)
{
foreach (var image in movie.Images)
{
var existingLink = DbContext.MovieImageDatas.Find(new object[] { image.MovieId, image.Id });
if (existingLink != null)
{
continue;
}
var existingMovie = DbContext.Movies.Find(new object[] { image.MovieId });
if (existingMovie == null)
{
throw new InvalidOperationException("Se esperaba encontrar pelicula para agregar personas");
}
existingMovie.Images.Add(new MovieImageData
{
Id = image.Id,
Movie = existingMovie,
MovieId = existingMovie.Id,
Image = image.Image,
Title = image.Title
});
}
//TODO: refactor this
foreach (var moviePerson in movie.ActorList)
{
var existingLink = DbContext.MovieActors.Find(new object[] { moviePerson.MovieId, moviePerson.PersonId });
if (existingLink != null)
{
continue;
}
var existingPerson = DbContext.People.Find(new object[] { moviePerson.PersonId });
if (existingPerson == null)
{
DbContext.People.Add(moviePerson.Person);
existingPerson = DbContext.People.Find(new object[] { moviePerson.PersonId });
}
var existingMovie = DbContext.Movies.Find(new object[] { moviePerson.MovieId });
if (existingMovie == null)
{
throw new InvalidOperationException("Se esperaba encontrar pelicula para agregar personas");
}
var newLink = new MovieActor
{
Movie = existingMovie,
MovieId = existingMovie.Id,
Person = existingPerson,
PersonId = existingPerson.Id,
AsCharacter = moviePerson.AsCharacter,
IsStar = moviePerson.IsStar
};
DbContext.MovieActors.Add(newLink);
}
foreach (var moviePerson in movie.WriterList)
{
var existingLink = DbContext.MovieWriters.Find(new object[] { moviePerson.MovieId, moviePerson.PersonId });
if (existingLink != null)
{
continue;
}
var existingPerson = DbContext.People.Find(new object[] { moviePerson.PersonId });
if (existingPerson == null)
{
DbContext.People.Add(moviePerson.Person);
existingPerson = DbContext.People.Find(new object[] { moviePerson.PersonId });
}
var existingMovie = DbContext.Movies.Find(new object[] { moviePerson.MovieId });
if (existingMovie == null)
{
throw new InvalidOperationException("Se esperaba encontrar pelicula para agregar personas");
}
var newLink = new MovieWriter
{
Movie = existingMovie,
MovieId = existingMovie.Id,
Person = existingPerson,
PersonId = existingPerson.Id,
};
DbContext.MovieWriters.Add(newLink);
}
foreach (var moviePerson in movie.DirectorList)
{
var existingLink = DbContext.MovieDirectors.Find(new object[] { moviePerson.MovieId, moviePerson.PersonId });
if (existingLink != null)
{
continue;
}
var existingPerson = DbContext.People.Find(new object[] { moviePerson.PersonId });
if (existingPerson == null)
{
DbContext.People.Add(moviePerson.Person);
existingPerson = DbContext.People.Find(new object[] { moviePerson.PersonId });
}
var existingMovie = DbContext.Movies.Find(new object[] { moviePerson.MovieId });
if (existingMovie == null)
{
throw new InvalidOperationException("Se esperaba encontrar pelicula para agregar personas");
}
var newLink = new MovieDirector
{
Movie = existingMovie,
MovieId = existingMovie.Id,
Person = existingPerson,
PersonId = existingPerson.Id,
};
DbContext.MovieDirectors.Add(newLink);
}
foreach (var movieSimilar in movie.Similars)
{
var existingLink = DbContext.MovieSimilars.Find(new object[] { movieSimilar.MovieId, movieSimilar.SimilarId });
if (existingLink != null)
{
continue;
}
var existingSimilar = DbContext.Movies.Find(new object[] { movieSimilar.SimilarId });
if (existingSimilar == null)
{
DbContext.Movies.Add(movieSimilar.Similar);
existingSimilar = DbContext.Movies.Find(new object[] { movieSimilar.SimilarId });
}
var existingMovie = DbContext.Movies.Find(new object[] { movieSimilar.MovieId });
if (existingMovie == null)
{
throw new InvalidOperationException("Se esperaba encontrar pelicula para agregar personas");
}
var newLink = new MovieSimilar
{
Movie = existingMovie,
MovieId = existingMovie.Id,
Similar = existingSimilar,
SimilarId = existingSimilar.Id,
};
DbContext.MovieSimilars.Add(newLink);
}
foreach (var movieCompany in movie.CompanyList)
{
var existingLink = DbContext.MovieCompanies.Find(new object[] { movieCompany.MovieId, movieCompany.CompanyId });
if (existingLink != null)
{
continue;
}
var existingCompany = DbContext.Companies.Find(new object[] { movieCompany.CompanyId });
if (existingCompany == null)
{
DbContext.Companies.Add(movieCompany.Company);
existingCompany = DbContext.Companies.Find(new object[] { movieCompany.CompanyId });
}
var existingMovie = DbContext.Movies.Find(new object[] { movieCompany.MovieId });
if (existingMovie == null)
{
throw new InvalidOperationException("Se esperaba encontrar pelicula para agregar personas");
}
var newLink = new MovieCompany
{
Movie = existingMovie,
MovieId = existingMovie.Id,
Company = existingCompany,
CompanyId = existingCompany.Id,
};
DbContext.MovieCompanies.Add(newLink);
}
}
public void RollMovie()
{
GameObject sr = GameObject.Find("Rings");
movieDirector = new MovieDirector();
movieDirector.RollMovie(allStagePersonObjectsList);
movieDirector.RandomPersonCycle();
sr.GetComponent<SelectorRings>().MovieMode();
}
/// <summary>
/// Adds the provided Movie and all associated information (Actors, Directors, Genres,
/// Languages, Tags) to the provided context. Assumes the all Movie information is
/// unique, GetRandomMovie() provides a Movie with information that is astronomically
/// unlikely to repeat.
/// </summary>
/// <param name="context"></param>
/// <param name="movieDTO"></param>
public static void AddMovieDTOToDatabase(Cinephiliacs_MovieContext context, MovieDTO movieDTO)
{
Movie movie = new Movie();
movie.ImdbId = movieDTO.ImdbId;
movie.Title = movieDTO.Title;
Rating newRating = new Rating();
newRating.RatingName = movieDTO.RatingName;
context.Ratings.Add(newRating);
context.SaveChanges();
movie.RatingId = context.Ratings.FirstOrDefault(r => r.RatingName == movieDTO.RatingName).RatingId;
movie.ReleaseDate = DateTime.ParseExact(movieDTO.ReleaseDate, "yyyy-MM-dd", CultureInfo.InvariantCulture);
movie.IsReleased = true;
movie.ReleaseCountry = movieDTO.ReleaseCountry;
movie.RuntimeMinutes = movieDTO.RuntimeMinutes;
movie.Plot = movieDTO.Plot;
movie.PosterUrl = movieDTO.PosterURL;
context.Movies.Add(movie);
context.SaveChanges();
foreach (var movieActorName in movieDTO.MovieActors)
{
Actor newActor = new Actor();
newActor.ActorName = movieActorName;
context.Actors.Add(newActor);
context.SaveChanges();
Actor actor = context.Actors.FirstOrDefault(a => a.ActorName == movieActorName);
MovieActor movieActor = new MovieActor();
movieActor.ImdbId = movieDTO.ImdbId;
movieActor.ActorId = actor.ActorId;
context.MovieActors.Add(movieActor);
context.SaveChanges();
}
foreach (var movieDirectorName in movieDTO.MovieDirectors)
{
Director newDirector = new Director();
newDirector.DirectorName = movieDirectorName;
context.Directors.Add(newDirector);
context.SaveChanges();
Director director = context.Directors.FirstOrDefault(d => d.DirectorName == movieDirectorName);
MovieDirector movieDirector = new MovieDirector();
movieDirector.ImdbId = movieDTO.ImdbId;
movieDirector.DirectorId = director.DirectorId;
context.MovieDirectors.Add(movieDirector);
context.SaveChanges();
}
foreach (var movieGenreName in movieDTO.MovieGenres)
{
Genre newGenre = new Genre();
newGenre.GenreName = movieGenreName;
context.Genres.Add(newGenre);
context.SaveChanges();
Genre genre = context.Genres.FirstOrDefault(a => a.GenreName == movieGenreName);
MovieGenre movieGenre = new MovieGenre();
movieGenre.ImdbId = movieDTO.ImdbId;
movieGenre.GenreId = genre.GenreId;
context.MovieGenres.Add(movieGenre);
context.SaveChanges();
}
foreach (var movieLanguageName in movieDTO.MovieLanguages)
{
Language newLanguage = new Language();
newLanguage.LanguageName = movieLanguageName;
context.Languages.Add(newLanguage);
context.SaveChanges();
Language language = context.Languages.FirstOrDefault(a => a.LanguageName == movieLanguageName);
MovieLanguage movieLanguage = new MovieLanguage();
movieLanguage.ImdbId = movieDTO.ImdbId;
movieLanguage.LanguageId = language.LanguageId;
context.MovieLanguages.Add(movieLanguage);
context.SaveChanges();
}
foreach (var movieTagName in movieDTO.MovieTags)
{
Tag newTag = new Tag();
newTag.TagName = movieTagName;
newTag.IsBanned = false;
context.Tags.Add(newTag);
context.SaveChanges();
MovieTag movieTag = new MovieTag();
movieTag.ImdbId = movieDTO.ImdbId;
movieTag.TagName = movieTagName;
movieTag.VoteSum = 1;
context.MovieTags.Add(movieTag);
context.SaveChanges();
}
}
public async Task EditActorAsync(EditMovieInputModel input)
{
var entity = this.moviesRepository.All()
.Where(x => x.Id == input.Id)
.FirstOrDefault();
entity.Actors = this.actorsMovieRepository.All()
.Where(x => x.MovieId == input.Id)
.ToList();
entity.Directors = this.directorMovieRepository.All()
.Where(x => x.MovieId == input.Id)
.ToList();
entity.Genres = this.genreMoviesRepository.All()
.Where(x => x.MovieId == input.Id)
.ToList();
ICollection <MovieActors> inputActors = new HashSet <MovieActors>();
foreach (var actor in input.Actors)
{
var actorMovie = new MovieActors
{
ActorId = actor,
MovieId = entity.Id,
};
if (entity.Actors.Contains(actorMovie))
{
continue;
}
if (!input.Actors.Contains(actorMovie.ActorId))
{
entity.Actors.Remove(actorMovie);
}
inputActors.Add(actorMovie);
}
ICollection <MovieGenre> inputGenres = new HashSet <MovieGenre>();
foreach (var genre in input.Genres)
{
var parsedGenreId = int.Parse(genre);
var genreMovie = new MovieGenre
{
GenreId = parsedGenreId,
MovieId = entity.Id,
};
if (entity.Genres.Contains(genreMovie))
{
continue;
}
if (!input.Genres.Contains(genreMovie.GenreId.ToString()))
{
entity.Genres.Remove(genreMovie);
}
inputGenres.Add(genreMovie);
}
ICollection <MovieDirector> inputDirectors = new HashSet <MovieDirector>();
foreach (var director in input.Directors)
{
var directorMovie = new MovieDirector
{
DirectorId = director,
MovieId = entity.Id,
};
if (entity.Directors.Contains(directorMovie))
{
continue;
}
if (!input.Directors.Contains(directorMovie.DirectorId))
{
entity.Directors.Remove(directorMovie);
}
inputDirectors.Add(directorMovie);
}
entity.Actors = inputActors;
entity.Genres = inputGenres;
entity.Directors = inputDirectors;
entity.IMDBLink = input.IMDBLink;
entity.Language = input.Language;
entity.Name = input.Name;
entity.PosterUrl = input.PosterUrl;
entity.Rating = input.Rating;
entity.ReleaseDate = input.ReleaseDate;
entity.TrailerLink = input.TrailerLink;
entity.Summary = input.Summary;
this.moviesRepository.Update(entity);
await this.moviesRepository.SaveChangesAsync();
}
public async Task AddMovieDirectorAsync(MovieDirector movieDirector)
{
await _dbContext.MovieDirector.AddAsync(movieDirector);
await _dbContext.SaveChangesAsync();
}
public CreateMovieDirectorCommand(MovieDirector movieDirector)
{
MovieDirector = movieDirector;
}
