public ActionResult Edit(Movie movie)
{
var repo = new MovieRepo();
int id = repo.SaveOrUpdate(movie);
return(Redirect("~/Movie/Detail/" + id));
}
public MovieLogic(IMovieContext context, IRoomContext roomContext, IApiHelper apiHelper, IAiringMovieContext airingMovieContext)
{
_repo = new MovieRepo(context, apiHelper);
_roomLogic = new RoomLogic(roomContext);
_airingMovieLogic = new AiringMovieLogic(airingMovieContext, roomContext);
_reviewLogic = new ReviewLogic();
}
public async Task Calendar_Movies_OnlyGet_PreviousAndFuture_90_Days()
{
var movies = new List <MovieRequests>
{
new MovieRequests
{
Title = "Invalid",
ReleaseDate = new DateTime(2018, 10, 01)
},
new MovieRequests
{
Title = "Invalid",
ReleaseDate = DateTime.Now.AddDays(91)
},
new MovieRequests
{
Title = "Valid",
ReleaseDate = DateTime.Now
}
};
MovieRepo.Setup(x => x.GetAll()).Returns(movies.AsQueryable());
var data = await CalendarEngine.GetCalendarData();
Assert.That(data.Count, Is.EqualTo(1));
Assert.That(data[0].Title, Is.EqualTo("Valid"));
}
public ActionResult Edit(int ID)
{
var repo = new MovieRepo();
var movie = repo.GetByID(ID);
return(View(movie));
}
public IActionResult Detail(string Id)
{
DetailViewModel detail = new DetailViewModel();
detail.Movie = MovieRepo.Get(Id);
return(View(detail));
}
public PartialViewResult Movies(int Id)
{
var repo = new MovieRepo();
var movies = repo.GetByGenreId(Id).Result;
return(PartialView(movies));
}
public MovieServiceBuilder()
{
_dbContext = new DapperContext(new ConfigBuilder().Build());
_movieRelationRepo = new MovieRelationRepo(_dbContext);
_movieHistoryRepo = new MovieHistoryRepo(_dbContext);
_movieRepo = new MovieRepo(_dbContext, _movieRelationRepo, _movieHistoryRepo);
_logger = new LoggerBuilder <MovieService>().Build();
}
public IActionResult Index()
{
IndexViewModel viewModel = new IndexViewModel();
viewModel.HighRatings = MovieRepo.GetAll().Where(f => f.Rating.AverageRating >= 70).Take(5).ToList();
viewModel.All = MovieRepo.GetAll().ToList();
viewModel.RecentlyAdded = MovieRepo.GetAll().Take(4).ToList();
return(View("index", viewModel));
}
/// <summary>
/// Gets movies for dropdown
/// </summary>
/// <returns>List of simple movie data objects</returns>
public async Task <IEnumerable <MovieForDropdown> > GetForDropdown()
{
var movies = await MovieRepo
.GetAll()
.AsNoTracking()
.ToListAsync();
return(Mapper.Map <IEnumerable <MovieForDropdown> >(movies));
}
/// <summary>
/// Gets movie by title and release date
/// </summary>
/// <param name="title">Movie title</param>
/// <param name="date">Movie release date</param>
/// <returns>Movie details</returns>
public async Task <MovieDetails> GetMovie(string title, DateTime date)
{
var movie = await MovieRepo
.GetAll(m => m.Title == title && m.ReleaseDate == date)
.FirstOrDefaultAsync();
var result = Mapper.Map <MovieDetails>(movie);
return(result);
}
public IActionResult BuyAll()
{
string[] InBasketIds = BasketRepo.Get(User.GetUserId()).UserBasket.Ids.ToArray();
foreach (var item in InBasketIds)
{
var movie = MovieRepo.Get(item);
BuyItem(movie);
}
return(this.RedirectToAction("PaymentHistory"));
}
public ActionResult Index(string searchTerm = null, int page = 1)
{
var repo = new MovieRepo();
var movies = repo.GetAllEntries().Where(m => searchTerm == null || m.Name.ToLower()
.Contains(searchTerm.ToLower())).ToPagedList(page, 10);
if (Request.IsAjaxRequest())
{
return(PartialView("_MovieList", movies));
}
return(View(movies));
}
public async Task <MovieDetails> AddMovie(MovieAddRequest request)
{
var movieToAdd = Mapper.Map <Movie>(request);
await MovieRepo.CreateAsync(movieToAdd);
await MovieRepo.SaveChangesAsync();
var addedMovie = Mapper.Map <MovieDetails>(movieToAdd);
return(addedMovie);
}
public IActionResult Filtered(int Id)
{
FilteredViewModel viewModel = new FilteredViewModel();
viewModel.CategoryName = CatRepo.Get(Id)?.Name;
if (viewModel.CategoryName == null)
{
return(NotFound());
}
viewModel.Filtered = MovieRepo.GetAll().Where(f => f.Categories.Any(f => f.CategoryId == Id)).ToList();
return(View(viewModel));
}
public async Task SearchAsync_Null_ShouldThrowArgumentNullException(string emptyString)
{
//Arrange
IClient client = _clientMock.Object;
IApiKeyConfiguration apiKeyConfiguration = _apiKeyConfigurationMock.Object;
MovieRepo repo = new MovieRepo(client, apiKeyConfiguration);
//Act
Func <Task> action = async() => await repo.SearchAsync(emptyString);
//Assert
await Assert.ThrowsAsync <ArgumentException>(action);
}
public ActionResult Autocomplete(string term)
{
var repo = new MovieRepo();
var model = repo.GetAllEntries().Where(m => m.Name.ToLower().StartsWith(term.ToLower()))
.Take(10)
.Select(m => new
{
label = m.Name
});
List <Movie> temp = repo.GetAllEntries().Where(m => m.Name.ToLower().StartsWith(term.ToLower())).ToList();
return(Json(model.ToList(), JsonRequestBehavior.AllowGet));
}
public IEnumerable <SearchResultItem> Search(string freeText, bool ignoreCase)
{
IEnumerable <SearchResultItem> movieResult = MovieRepo.GetAllMovies().Where(m => m.Title.Contains(freeText, ignoreCase) ||
m.ProductionYear.Value.ToString().Contains(freeText, ignoreCase)
).Select(m => new MovieSearchResultItem(m));
IEnumerable <SearchResultItem> castOrCrewResult = CastOrCrewRepo.GetAllPeople().Where(p => p.Name.Contains(freeText, ignoreCase) ||
p.DateOfBirth.Year.ToString().Contains(freeText, ignoreCase)
).Select(p => new CastOrCrewSearchResultItem(p));
var result = movieResult.Concat(castOrCrewResult);
return(result);
}
public async Task SearchAsync_ValidSearch_ShouldReturnListOfMovies(string query)
{
//Arrange
IClient client = _clientMock.Object;
IApiKeyConfiguration apiKeyConfiguration = _apiKeyConfigurationMock.Object;
MovieRepo repo = new MovieRepo(client, apiKeyConfiguration);
//Act
var result = await repo.SearchAsync(query);
//Assert
Assert.NotNull(result);
}
public ActionResult MoviesList()
{
DataTable dt = MovieRepo.GetMovies();
List <Movie> dtr =
(from DataRow dr in dt.Rows
select new Movie()
{
FilmID = Convert.ToInt32(dr["FilmID"]),
FilmName = dr["FilmName"].ToString(),
FilmReleaseDate = Convert.ToDateTime(dr["FilmReleaseDate"].ToString()),
FilmDirectorID = Convert.ToInt32(dr["FilmDirectorID"]),
FilmSynopsis = dr["FilmSynopsis"].ToString()
}).ToList(); //MovieRepo.GetMovies().AsEnumerable().ToList();
return(View(dtr));
}
public IActionResult Buy(string Id)
{
var movie = MovieRepo.Get(Id);
if (movie == null)
{
return(NotFound());
}
var userPayments = PaymentRepo.Get(User.GetUserId());
if (userPayments.FirstOrDefault(f => f.MovieId == movie.Id) == null)
{
BuyItem(movie);
}
return(this.RedirectToAction("PaymentHistory"));
}
public void TestMovieAddHistory()
{
var dbContext = new DapperContext(new ConfigBuilder().Build());
var movieRelationRepo = new MovieRelationRepo(dbContext);
var movieHistoryRepo = new MovieHistoryRepo(dbContext);
var movieRepo = new MovieRepo(dbContext, movieRelationRepo, movieHistoryRepo);
var movie = new Movie()
{
IdMovie = 1, Number = "PPPP-001", Actor = "my actor", Category = "我是jiajia", Title = "※未成年※コンドーム一切無し※19歳スケベ剥き出し温泉旅行※4本番やりらふぃー※モデルの卵ちゃん"
};
List <MovieHistory> movieHistories = movieRepo.AddHistory(movie);
movieHistories.ForEach(h => _output.WriteLine(h.DescHistory));
_movieService.SaveMovie(movie);
}
public IActionResult AddToBasket(string Id)
{
var movie = MovieRepo.Get(Id);
if (movie == null)
{
return(NotFound());
}
var usrBasket = BasketRepo.Get(User.GetUserId());
if (!usrBasket.UserBasket.Ids.Contains(Id))
{
usrBasket.UserBasket.Ids.Add(Id);
usrBasket.UserBasket = usrBasket.UserBasket;
BasketRepo.SaveChanges();
}
return(this.RedirectToAction("Basket"));
}
public async Task <bool> UpdateMovie(MovieUpdateRequest request)
{
var movie = await MovieRepo
.GetAll()
.FirstOrDefaultAsync(m => m.Id == request.Id);
if (movie == null)
{
return(false);
}
Mapper.Map(request, movie);
MovieRepo.Update(movie);
await MovieRepo.SaveChangesAsync();
return(true);
}
/// <summary>
/// Gets movie by id
/// </summary>
/// <param name="id">Movie id</param>
/// <param name="noTracking">Should movie be tacked</param>
/// <returns>Movie details</returns>
public async Task <MovieDetails> GetMovie(Guid id, bool noTracking = false)
{
var movies = MovieRepo
.GetAll()
.Include(m => m.Images)
.ThenInclude(i => i.Image);
if (noTracking)
{
movies.AsNoTracking();
}
var movie = await movies.FirstOrDefaultAsync(m => m.Id == id);
var result = Mapper.Map <MovieDetails>(movie);
return(result);
}
public async Task <string> Calendar_Movie_StatusColor(AvailabilityTestModel model)
{
var movies = new List <MovieRequests>
{
new MovieRequests
{
Title = "Valid",
ReleaseDate = DateTime.Now,
Denied = model.Denied,
Approved = model.Approved,
Available = model.Available
},
};
MovieRepo.Setup(x => x.GetAll()).Returns(movies.AsQueryable());
var data = await CalendarEngine.GetCalendarData();
return(data[0].BackgroundColor);
}
public void ShouldReturnKubrickFilm()
{
var expectedMovie = new Movie()
{
Name = "Full Metal Jacket",
Director = "Stanley Kubrick",
Language = "en-us"
};
MovieRepo
.Setup(repo => repo.GetMovies())
.Returns(allMovies.Append(CloneMovie(expectedMovie)));
TranslationService
.Setup(service => service.Translate(It.IsAny <string>(), It.IsAny <CultureInfo>()))
.Returns("Have you ever seen a Commie drink a glass of water?");
var actualMovie = MovieFinder.GetMoviesByDirector("Stanley Kubrick").First();
Assert.Equal(expectedMovie.Director, actualMovie.Director);
Assert.Equal(expectedMovie.Name, actualMovie.Name);
Assert.Equal(expectedMovie.Language, actualMovie.Language);
}
public IActionResult Basket()
{
if (!User.Identity.IsAuthenticated)
{
return(this.Redirect("~/Identity/Account/Login"));
}
var id = User.GetUserId();
User user = UserRepo.Get(id);
if (user.Basket == null)
{
user.Basket = new Basket();
UserRepo.SaveChanges();
}
List <Movie> movies = new List <Movie>();
foreach (var item in user.Basket.UserBasket.Ids)
{
movies.Add(MovieRepo.Get(item));
}
return(View(movies));
}
/// <summary>
/// Gets all movies
/// </summary>
/// <returns>List of movies for list/table</returns>
public async Task <IEnumerable <MovieForList> > GetMovies()
{
var movies = await MovieRepo
.GetAll()
.ToListAsync();
var result = Mapper.Map <IEnumerable <MovieForList> >(movies);
foreach (var m in result)
{
var thumbnail = await MovieImageRepo
.GetAll(i => i.MovieId == m.Id && i.ImageType == MovieImageType.Cover)
.Include(i => i.Image)
.FirstOrDefaultAsync();
if (thumbnail != null)
{
m.ThumbnailUrl = thumbnail.Image.Url;
}
}
return(result);
}
public async Task <OmbiIdentityResult> DeleteUser(string userId)
{
var userToDelete = await UserManager.Users.FirstOrDefaultAsync(x => x.Id == userId);
if (userToDelete != null)
{
// Can we delete this user?
var userRoles = await UserManager.GetRolesAsync(userToDelete);
if (!CanModifyUser(userRoles))
{
return(Error("You do not have the correct permissions to delete this user"));
}
// We need to delete all the requests first
var moviesUserRequested = MovieRepo.GetAll().Where(x => x.RequestedUserId == userId);
var tvUserRequested = TvRepo.GetChild().Where(x => x.RequestedUserId == userId);
var musicRequested = MusicRepo.GetAll().Where(x => x.RequestedUserId == userId);
var notificationPreferences = _userNotificationPreferences.GetAll().Where(x => x.UserId == userId);
var userQuality = await _userQualityProfiles.GetAll().FirstOrDefaultAsync(x => x.UserId == userId);
if (moviesUserRequested.Any())
{
await MovieRepo.DeleteRange(moviesUserRequested);
}
if (tvUserRequested.Any())
{
await TvRepo.DeleteChildRange(tvUserRequested);
}
if (musicRequested.Any())
{
await MusicRepo.DeleteRange(musicRequested);
}
if (notificationPreferences.Any())
{
await _userNotificationPreferences.DeleteRange(notificationPreferences);
}
if (userQuality != null)
{
await _userQualityProfiles.Delete(userQuality);
}
// Delete any issues and request logs
var issues = _issuesRepository.GetAll().Where(x => x.UserReportedId == userId);
var issueComments = _issueCommentsRepository.GetAll().Where(x => x.UserId == userId);
var requestLog = _requestLogRepository.GetAll().Where(x => x.UserId == userId);
if (issues.Any())
{
await _issuesRepository.DeleteRange(issues);
}
if (requestLog.Any())
{
await _requestLogRepository.DeleteRange(requestLog);
}
if (issueComments.Any())
{
await _issueCommentsRepository.DeleteRange(issueComments);
}
// Delete the Subscriptions and mobile notification ids
var subs = _requestSubscriptionRepository.GetAll().Where(x => x.UserId == userId);
var mobileIds = _notificationRepository.GetAll().Where(x => x.UserId == userId);
if (subs.Any())
{
await _requestSubscriptionRepository.DeleteRange(subs);
}
if (mobileIds.Any())
{
await _notificationRepository.DeleteRange(mobileIds);
}
var result = await UserManager.DeleteAsync(userToDelete);
if (result.Succeeded)
{
return(new OmbiIdentityResult
{
Successful = true
});
}
return(new OmbiIdentityResult
{
Errors = result.Errors.Select(x => x.Description).ToList()
});
}
return(Error("Could not find user to delete."));
}
public MovieService()
{
_repo = new MovieRepo();
}
