public FilmViewModel findMostFrequentFilms(FilmListViewModel films)
{
FilmViewModel film = null;
film = films.Films.GroupBy(value => value.Id).OrderByDescending(group => group.Count()).SelectMany(group => group).First();
return(film);
}
public async Task <IActionResult> Update(FilmViewModel model, IFormFileCollection posters)
{
if (!ModelState.IsValid)
{
return(View(model));
}
Film film = await _filmRepository.GetByIdAsync(model.Id);
film.Id = model.Id;
film.Name = model.Name;
film.Description = model.Description;
film.AgeLimit = model.AgeLimit;
film.ReleaseDate = model.ReleaseDate;
film.Duration = model.Duration;
film.Trailer.Url = model.TrailerUrl;
List <FilmPoster> filmPosters = await SavePostersImages(film.Id, posters);
film.Posters.AddRange(filmPosters);
await _filmRepository.UpdateAsync(film);
return(RedirectToAction("Index", "Admin"));
}
public static void AddFilm(
FilmViewModel film,
ref MyObservableCollection <ActorViewModel> actors,
ref MyObservableCollection <ProducerViewModel> producers)
{
foreach (var actor in film?.Actors)
{
bool res = false;
foreach (var act in actors)
{
if (act.FullName == actor.FullName)
{
res = true;
}
}
if (!res)
{
actors.Add(actor);
}
}
var prod = film.Prod;
bool res1 = false;
foreach (var producer in producers)
{
if (producer.Name == prod.Name)
{
res1 = true;
}
}
if (!res1)
{
producers.Add(new ProducerViewModel(prod));
}
}
public ActionResult Create()
{
ViewBag.Categories = repo.Categories.ToList();
var model = new FilmViewModel();
return(View(model));
}
public static List <FilmViewModel> GetFilms(string condition)
{
var films = new List <FilmViewModel>();
var sqlExpression = $"SELECT id, title, image_path, release_year FROM movies WHERE is_rent = 1 {condition}";
void addValues(NpgsqlDataReader reader)
{
var film = new FilmViewModel()
{
Id = (int)reader.GetValue(0),
Name = reader.GetValue(1).ToString(),
ImagePath = reader.GetValue(2).ToString(),
Year = (int)reader.GetValue(3)
};
films.Add(film);
}
DAOFactory.ToHandleRequest(sqlExpression, addValues);
foreach (var film in films)
{
film.Genres = FilmViewModelDAO.GetGenresByFilmId(film.Id, true);
}
return(films);
}
public IHttpActionResult GetFilmViewModel(int id)
{
FilmDto film;
List <string> superheroNames;
film = filmRepository.GetById(id);
if (film == null)
{
return(NotFound());
}
superheroNames = filmSuperheroesRepository.GetSuperheroesByFilm(id).ToList();
var result = new FilmViewModel
{
FilmId = film.FilmId,
critics = film.critics,
filmName = film.filmName,
income = film.income,
userRating = film.userRating,
year = film.year,
superheroes = superheroNames
};
return(Ok(result));
}
// GET: Films
public async Task <IActionResult> Index(string filmEtiket, string searchString)
{
IQueryable <string> etiketQuery = from m in _context.Films
orderby m.Etiket
select m.Etiket;
var movies = from m in _context.Films
select m;
if (!String.IsNullOrEmpty(searchString))
{
movies = movies.Where(s => s.Baslik.Contains(searchString));
}
if (!string.IsNullOrEmpty(filmEtiket))
{
movies = movies.Where(x => x.Etiket == filmEtiket);
}
var filmVM = new FilmViewModel
{
Etiketler = new SelectList(await etiketQuery.Distinct().ToListAsync()),
Filmler = await movies.ToListAsync()
};
return(View(filmVM));
}
public async Task <IActionResult> AddToCart(int id, [FromQuery] int count, [FromQuery] string returnUrl)
{
FilmDTO filmDTO = await _orderService.GetFilmAsync(id);
var mapper = MapperService.CreateFilmDTOToFilmViewModelMapper();
FilmViewModel film = mapper.Map <FilmDTO, FilmViewModel>(filmDTO);
List <FilmViewModel> films = new List <FilmViewModel>();
if (returnUrl == null)
{
returnUrl = "~/Home/Index";
}
for (int i = 0; i < count; i++)
{
films.Add(film);
}
AddFilmsToCart("CartFilms", films);
if (returnUrl.Contains("Cart"))
{
return(RedirectToAction("Cart"));
}
return(Redirect(returnUrl));
}
public List <FilmViewModel> GetAllFilms(string userId)
{
var films = new List <FilmViewModel>();
var userFilm = GetUserFilmViewModel();
var generalFilm = GetGeneralFilmViewModel();
foreach (var film in FilmHausDbContext.Films.ToList())
{
var result = new FilmViewModel();
if (UserFilmRatingService.DoesUserHaveRating(userId, film.MediaId))
{
result = userFilm.Invoke(film.UserFilms
.Where(uf => uf.Id == userId && uf.MediaId == film.MediaId)
.FirstOrDefault()
);
}
else
{
result = generalFilm.Invoke(film);
result.InCurrentUserLibrary = UserFilmService.IsFilmInLibrary(film.MediaId, userId);
}
films.Add(result);
}
return(films);
}
public async Task <IActionResult> AddFilm(FilmViewModel filmVM)
{
Film film = new Film {
Name = filmVM.Name,
Descrpion = filmVM.Descrpion,
Year = filmVM.Year,
Producer = filmVM.Producer,
Username = filmVM.Username
};
//Записываем полученный файл в массив байтов
if (filmVM.Poster != null)
{
byte[] imageData = null;
using (var binaryReader = new System.IO.BinaryReader(filmVM.Poster.OpenReadStream()))
{
imageData = binaryReader.ReadBytes((int)filmVM.Poster.Length);
}
film.Poster = imageData;
}
db.Film.Add(film);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public static FilmContract getFilmContract(FilmViewModel data, string fileName)
{
var genres = new List <GenreContract>();
foreach (var item in data.Genre)
{
genres.Add(new GenreContract()
{
Id = item
});
}
var newFilm = new FilmContract()
{
Id = data.Id,
Description = data.Description,
Rate = data.Rate,
DirectorId = data.DirectorId,
PhotoName = fileName,
Title = data.Title,
Year = data.Year,
Genre = genres.ToArray()
};
return(newFilm);
}
public async Task <ActionResult> EditFilm(int id, FilmViewModel updatedFilm)
{
var film = FilmStore.Films.SingleOrDefault(x => x.Id == id);
var url = WebProxyHelper.RemoveProxyDecoration(updatedFilm.Url);
if (film == null)
{
return(_Failure("Film with id {0} not found!", id));
}
var parser = await WebsiteParserFactory.CreateParserForUrl(url);
if (parser == null)
{
return(_Failure("No parser found for {0}!", url));
}
film.Name = updatedFilm.Name;
film.Url = url;
film.Season = updatedFilm.Season;
film.Episode = updatedFilm.Episode;
film.CoverUrl = updatedFilm.CoverUrl;
await FilmStore.SaveChangesAsync();
return(_Success());
}
public async Task <ActionResult> AddFilm(FilmViewModel model)
{
var url = WebProxyHelper.RemoveProxyDecoration(model.Url);
var film = new Film
{
Name = model.Name,
Url = url,
CoverUrl = model.CoverUrl,
Season = model.Season > 0 ? model.Season : 1,
Episode = model.Episode > 0 ? model.Episode : 1,
IsFavorite = model.IsFavorite
};
var parser = await WebsiteParserFactory.CreateParserForUrl(url);
if (parser == null)
{
return(_Failure("No parser found for {0}!", url));
}
film.IsFavorite = true;
FilmStore.AddFilm(film);
await FilmStore.SaveChangesAsync();
return(_Success());
}
public ActionResult Delete(long filmId)
{
FilmDomainModel filmDomainModel = _filmService.ReadById(filmId);
if (filmDomainModel == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
FilmViewModel filmViewModel = Mapper.Map <FilmDomainModel, FilmViewModel>(filmDomainModel);
if (!ModelState.IsValid)
{
return(View("Delete", filmViewModel));
}
//TODO: have to put this code in a separate helper (type of FileManager)
var virtualPath = filmDomainModel.ImagePath;
var physicalPath = HttpContext.Server.MapPath(virtualPath);
if (System.IO.File.Exists(physicalPath))
{
System.IO.File.Delete(physicalPath);
}
_filmService.Delete(filmDomainModel);
return(RedirectToAction("Index"));
}
public IActionResult Index(FilmViewModel model)
{
Film f = filmService.findById(model.codigo);
model.move = (f is null) ? "Filme não Existe" : f.Title;
return(View(model));
}
// GET: Films/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
// var film = await _context.Films.FindAsync(id);
var film = await _context.Films.FirstOrDefaultAsync(n => n.Id == id);
IQueryable <Film> source = _context.Films;
var items = await source.Where(n => n.Id == id).FirstOrDefaultAsync();
FilmViewModel viewModel = new FilmViewModel
{
//Poster = items.Poster
Id = film.Id,
Title = film.Title,
Description = film.Description,
Year = film.Year,
Director = film.Director,
Poster = null
};
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
if (film == null || film.AddedByUserId != userId)
{
return(NotFound());
}
return(View(viewModel));
}
public async Task <IActionResult> Edit(FilmViewModel filmViewModel)
{
var mapper = MapperService.CreateFilmViewModelToFilmDTOMapper();
if (ModelState.IsValid)
{
var filmDTO = mapper.Map <FilmViewModel, FilmDTO>(filmViewModel);
if (filmViewModel.Image != null)
{
string path = "/Files/Posters/" + filmViewModel.Image.FileName;
using (FileStream fs = new FileStream(_appEnvironment.WebRootPath + path, FileMode.Create))
{
await filmViewModel.Image.CopyToAsync(fs);
}
filmDTO.ImagePath = path;
}
await _adminService.SaveFilmAsync(filmDTO);
TempData["message"] = $"Changes in film {filmViewModel.Name} were saved successfully.";
return(RedirectToAction("Admin"));
}
else
{
return(RedirectToAction("Edit"));
}
}
public ActionResult AddFilmView(FilmViewModel model)
{
if (ModelState.IsValid)
{
var filmid = _allfilms.AddFilmView(model);
var ActorsString = model.Actors;
if (String.IsNullOrEmpty(ActorsString) == false)
{
String[] Numbers = ActorsString.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var element in Numbers)
{
int result;
bool success = Int32.TryParse(element, out result);
_allfilms.SaveActorForFilm(result, filmid);
}
}
return(RedirectToAction("ListAllFilms"));
}
var category = new SelectList(_allcategory.AllCategories, "Id", "CategoryName");
ViewBag.Category = category;
return(View(model));
}
private void EditFilmClick(object sender, EventArgs e)
{
var countSelectedRows = 0;
DataGridViewRow selectedRow = null;
foreach (var row in FilmsGrid.Rows.Cast <DataGridViewRow>().Where(row => row.Selected))
{
if (selectedRow == null)
{
selectedRow = row;
}
countSelectedRows++;
}
if (countSelectedRows != 1)
{
MessageBox.Show(this, Resources.PleaseSelectOnlyOneRowForEdit);
}
else
{
var filmView = selectedRow?.DataBoundItem as FilmViewModel;
if (filmView == null)
{
return;
}
_editedFilm = filmView;
_editFilmView.EditedFilm = filmView;
_editFilmView.ShowDialog(this);
}
}
public async Task <FilmViewModel> EditFilmAsync(FilmViewModel film)
{
if (film == null)
{
throw new NullReferenceException($"Параметр film не должен быть null!");
}
FilmDataModel model;
using (var ctx = new FilmsCatalogDbContext())
{
model = await ctx.Films
.Include("User")
.FirstOrDefaultAsync(f => f.Id == film.Id);
if (model == null)
{
throw new Exception($"Фильм с идентификатором {film.Id} не найден в базе данных!");
}
model.Name = film.Name;
model.Producer = film.Producer;
model.Description = film.Description;
model.CreateYear = film.CreateYear;
model.MimeType = film.MimeType;
model.FileName = film.FileName;
await ctx.SaveChangesAsync();
}
var filmMapper = new FilmModelMapper().CreateMapper();
return(filmMapper.Map <FilmViewModel>(model));
}
public ActionResult Edit(FilmViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var film = _db.Films.Find(model.Id);
if (film == null)
{
return(View("Error404"));
}
if (User.Identity.GetUserId() != film.User.Id)
{
return(RedirectToAction("View", new { Id = film.Id }));
}
film.Name = model.Name;
film.Year = model.Year;
film.Director = model.Director;
film.Description = model.Description;
if (model.FilePoster != null)
{
using (var binaryReader = new BinaryReader(model.FilePoster.InputStream))
{
film.Poster = binaryReader.ReadBytes(model.FilePoster.ContentLength);
}
}
_db.SaveChanges();
return(RedirectToAction("View", new { id = film.Id }));
}
public FilmViewModel GetFilmById(int id)
{
var film = new Film();
using (var ctx = new FilmsDbContext())
{
if (Properties.Settings.Default.UsStoredProcedure)
{
var idParam = new System.Data.SqlClient.SqlParameter("@id", id);
film = ctx.Database.SqlQuery <Film>("GetFilm @id", idParam)
.FirstOrDefault();
idParam = new System.Data.SqlClient.SqlParameter("@filmId", id);
film.Actors = ctx.Database.SqlQuery <Actor>("GetFilmActors @filmId", idParam).ToList();
idParam = new System.Data.SqlClient.SqlParameter("@filmId", id);
film.Ganre = ctx.Database.SqlQuery <Ganre>("GetFilmGanre @filmId", idParam).FirstOrDefault();
}
else
{
film = ctx.Films
.Include("Actors")
.Include("Ganre")
.FirstOrDefault(f => f.Id == id);
}
}
var filmView = new FilmViewModel();
if (film != null)
{
filmView = FilmToFilmViewModel(film);
}
return(filmView);
}
public void GetAllFilmsShouldReturnFilmsWhenRecordFoundInRepository()
{
FilmViewModel vm = new FilmViewModel();
vm.Results = new List <Result>()
{
new Result()
{
Director = "director",
Episode_Id = 4,
}
};
var json = JsonSerializer.Serialize(vm);
httpHandlerMock.Setup(x => x.GetAsync("/api/films/")).ReturnsAsync(json);
swapiRepositoryMock.Setup(x => x.GetAllFilms()).Returns(new List <Film>()
{
new Film()
{
EpisodeId = 4,
Average = 5,
Rate = 5,
Id = 1
}
});
var films = service.GetAllFilms().Result;
films.Should().NotBeNull();
films.Results.Select(p => p.Episode_Id).Should().BeEquivalentTo(4);
}
/// <summary>
/// Deletes entity for FilmViewModel.
/// </summary>
/// <param name="viewModel">The viewModel <see cref="FilmViewModel"/>.</param>
/// <returns>The <see cref="SimpleResponse"/>.</returns>
public SimpleResponse Delete(FilmViewModel model)
{
var response = new SimpleResponse();
try
{
using (var context = new PublicDbContext())
{
var entity = context.Film.FirstOrDefault(q => q.FilmId == model.FilmId);
if (entity == null || entity == default(Film))
{
response.ResponseCode = BusinessResponseValues.NullEntityValue;
response.ResponseMessage = "Kayýt bulunamadý.";
return(response);
}
context.Film.Remove(entity);
response.ResponseCode = context.SaveChanges();
}
}
catch (Exception ex)
{
response.ResponseCode = BusinessResponseValues.InternalError;
response.ResponseMessage = "Silme iþleminde hata oluþtu.";
DayLogger.Error(ex);
}
return(response);
}
public async Task <IActionResult> EntertainmentProduct(int?id)
{
if (id == null)
{
return(View("Error"));
}
Products product = await _context.Products.FindAsync(id);
if (product == null)
{
return(View("Error"));
}
ViewBag.Active = "Entertainment";
FilmViewModel viewModel = new FilmViewModel()
{
Product = product,
AllProducts = _context.Products.Where(p => p.BrandsId == product.BrandsId),
};
return(View(viewModel));
}
/// <summary>
/// The Creates entity for FilmViewModel.
/// </summary>
/// <param name="viewModel">The viewModel <see cref="FilmViewModel"/>.</param>
/// <returns>The <see cref="SimpleResponse{FilmViewModel}"/>.</returns>
public SimpleResponse <FilmViewModel> Create(FilmViewModel model)
{
var response = new SimpleResponse <FilmViewModel>();
try
{
var validation = model.Validate();
if (validation.HasError)
{
return(new SimpleResponse <FilmViewModel>
{
Data = model,
ResponseCode = BusinessResponseValues.ValidationErrorResult,
ResponseMessage = validation.AllValidationMessages
});
}
using (var context = new PublicDbContext())
{
var entity = Map <FilmViewModel, Film>(model);
context.Film.Add(entity);
response.ResponseCode = context.SaveChanges();
}
}
catch (Exception ex)
{
response.ResponseCode = BusinessResponseValues.InternalError;
response.ResponseMessage = "Ekleme iþleminde hata oluþtu.";
DayLogger.Error(ex);
}
return(response);
}
public async Task <IActionResult> Create(FilmViewModel model, IFormFileCollection posters)
{
if (!ModelState.IsValid)
{
return(View(model));
}
Film film = new Film
{
Name = model.Name,
Description = model.Description,
AgeLimit = model.AgeLimit,
ReleaseDate = model.ReleaseDate,
Duration = model.Duration
};
await _filmRepository.CreateAsync(film);
FilmTrailer trailer = new FilmTrailer
{
Url = model.TrailerUrl,
FilmId = film.Id
};
await _trailerRepository.CreateAsync(trailer);
film.Trailer = trailer;
List <FilmPoster> filmPosters = await SavePostersImages(film.Id, posters);
film.Posters.AddRange(filmPosters);
await _filmRepository.UpdateAsync(film);
return(RedirectToAction("Index", "Admin"));
}
private FilmViewModel GetFilmViewModel(Film film, User user, bool addImage)
{
User filmCreator = _userManager.Users.First(u => u.Id == film.AuthorId);
FilmViewModelType type = user != null && user.Id == filmCreator.Id ?
FilmViewModelType.Update : FilmViewModelType.Read;
var model = new FilmViewModel
{
Id = film.Id,
Name = film.Name,
Description = film.Description,
Year = film.Year,
Producer = film.Producer,
Publisher = filmCreator.GetUserName(),
Type = type
};
if (addImage)
{
model.PosterImageBase64WithMimeType = ImageUtils.ConvertToBase64WithMimeType(film.PosterImage);
}
return(model);
}
public ActionResult Create(FilmViewModel f, HttpPostedFileBase Image)
{
if (!ModelState.IsValid || Image == null || Image.ContentLength == 0)
{
RedirectToAction("Create");
}
f.ImageUrl = Image.FileName;
Film film = new Film {
Title = f.Title,
Description = f.Description,
Genre = f.Genre,
ImageUrl = f.ImageUrl,
OutDate = f.OutDate,
ProducteurId = f.ProducteurId
};
service.AddFilm(film);
service.SaveChange();
// Sauvgarde de l'image
var path = Path.Combine(Server.MapPath("~/Content/Upload/"), Image.FileName);
Image.SaveAs(path);
return(RedirectToAction("Index"));
}
public async Task<IActionResult> FilmView(int filmId) {
StarWarsApi<Film> apiResult = new StarWarsApi<Film>();
FilmViewModel model = new FilmViewModel() {
Film = await apiResult.RetrieveItem("films", filmId)
};
return View(model);
}
