public IActionResult Adicionar([FromBody] FilmeViewModel pFilme)
{
var filme = _mapper.Map <FilmeViewModel, Filme>(pFilme); // cria mapeamento da view model com entidade via automapper.
filme.Ativo = true;
filme.DataCriacao = DateTime.Now;
_filmeRepository.Adicionar(filme); // Add do entity framework
if (filme.EhValido())
{
_filmeRepository.SaveChanges(); // salva as alterações
// monta um obj anonimo para retono.
var retorno = new
{
id = filme.Id,
nome = filme.Nome,
genero = filme.GeneroId
};
return(Response(true, retorno)); // Retorna Ok código 200 para requisição
}
// Retorna 400.
return(Response(false, erros: filme.ValidationErrors));
}
public ActionResult Editar(int id)
{
var filme = _filmeBLONovo.BuscarPorId(id);
var generos = PegarSelectListaGenero();
var idiomas = PegarSelectListaIdioma();
var view = new FilmeViewModel(filme);
view.Generos.AddRange(generos);
view.Idiomas.AddRange(idiomas);
filmeTemp = view;
var listaNomesdeFilmes = _nomedoFilmeBLONovo.BuscarporIdFilme(filme.FilmeId).Select(x => new NomedoFilmeViewModel(x));
view.ListaNomedoFilme.AddRange(listaNomesdeFilmes);
var listaGeneros = _filmeGeneroBLONovo.BuscarporFilmeId(filme.FilmeId).Select(x => new GeneroViewModel(x));
view.ListaGeneros.AddRange(listaGeneros);
var listaIdiomas = _filmeIdiomaBLONovo.BuscarporIdFilme(filme.FilmeId).Select(x => new IdiomaViewModel(x));
view.ListaIdiomas.AddRange(listaIdiomas);
return(View(view));
}
public async Task <IActionResult> ManterFilme(string cod)
{
try
{
if (string.IsNullOrEmpty(cod))
{
FilmeViewModel filme = new FilmeViewModel();
return(View(filme));
}
else
{
ClientService client = new ClientService();
FilmeViewModel resultado = await client.GetAsync <FilmeViewModel>(_config["UrlApi"] + "/Filme/filme?IdFilme="
, User.Claims.Where(s => s.Type == "AccessToken").Select(s => s.Value).First(), cod);
return(View(resultado));
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Actualizar(FilmeViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.Generos = _dbContext.Genero.OrderBy(g => g.Descricao).ToList();
return(View("MostrarEditar", viewModel));
}
var filmeRegistado = _dbContext.Filmes.SingleOrDefault(f => f.Id == viewModel.Filme.Id);
if (filmeRegistado == null)
{
return(HttpNotFound());
}
// TODO: Refactorar com AutoMapper
filmeRegistado.Nome = viewModel.Filme.Nome;
filmeRegistado.Descricao = viewModel.Filme.Descricao;
filmeRegistado.DataLancamento = viewModel.Filme.DataLancamento;
filmeRegistado.QtdStock = viewModel.Filme.QtdStock;
filmeRegistado.Imdb = viewModel.Filme.Imdb;
filmeRegistado.GeneroId = viewModel.Filme.GeneroId;
_dbContext.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <FilmeViewModel> Atualizar(FilmeViewModel filmeViewModel)
{
var filme = new Filme(filmeViewModel.IdFilme, filmeViewModel.Nome, filmeViewModel.Ativo,
filmeViewModel.IdCriadoPor, filmeViewModel.IdAtualizadoPor, filmeViewModel.IdExcluidoPor);
BeginTransaction();
var atorServiceRetorno = _filmeService.Atualizar(filme);
filmeViewModel = _filmeServiceMapper.MapToFilmeViewModel(atorServiceRetorno);
if (!filmeViewModel.ValidationResult.IsValid)
{
return(filmeViewModel);
}
var sucessoCommit = await Commit();
if (!sucessoCommit)
{
if (!sucessoCommit)
{
filmeViewModel.ValidationResult.Errors.Add(new ValidationFailure("Commit", "Ocorreu um erro ao salvar as informações no banco de dados. Por favor, tente novamente"));
}
}
return(filmeViewModel);
}
public ActionResult Editar(FilmeViewModel view)
{
var retorno = new RetornoMensagem();
try
{
var filme = new Filme()
{
FilmeId = view.FilmeId,
Descricao = view.Descricao,
Generos = new List <Genero>(),
Idiomas = new List <Idioma>(),
Nomes = new List <NomedoFilme>()
};
if (filmeTemp.ListaGeneros.Any())
{
foreach (var item in filmeTemp.ListaGeneros)
{
var genero = new Genero {
GeneroId = item.GeneroId, Descricao = item.Descricao
};
filme.Generos.Add(genero);
}
}
if (filmeTemp.ListaIdiomas.Any())
{
foreach (var item in filmeTemp.ListaIdiomas)
{
var idioma = new Idioma {
IdiomaId = item.IdiomaId, Descricao = item.Descricao
};
filme.Idiomas.Add(idioma);
}
}
_filmeBLO.Editar(filme);
retorno.Mensagem
= "Filme Editado com Sucesso. <br />";
retorno.TipoMensagem = TipoMensagem.Sucesso;
retorno.Resultado = true;
}
catch (ProjetoException ex)
{
retorno.Mensagem = ex.Message;
retorno.TipoMensagem = TipoMensagem.Alerta;
retorno.Resultado = false;
}
catch (Exception ex)
{
retorno.Mensagem = "Erro ao Editar.<br />";
retorno.TipoMensagem = TipoMensagem.Erro;
retorno.Resultado = false;
}
return(Json(retorno));
}
public ViewResult MostrarNovo()
{
ViewBag.Generos = new SelectList(_dbContext.Genero.OrderBy(g => g.Descricao).ToList(), "Id", "Descricao");
var viewModel = new FilmeViewModel(new Filme());
viewModel.Filme.DataLancamento = new DateTime(1900, 01, 01);
return(View(viewModel));
}
// GET: Filmes/Create
public ActionResult Create()
{
var filmeVm = new FilmeViewModel();
filmeVm.GeneroSL = _unitOfWork.Filmes.GetGenresSL();
ViewBag.Title = "Novo Filme";
return(View("FilmesEditForm", filmeVm));
}
public ActionResult Edit([Bind(Include = "IdFilme,NomeFilme,IdAlbum")] FilmeViewModel viewModel)
{
if (ModelState.IsValid)
{
Filme filme = Mapper.Map <FilmeViewModel, Filme>(viewModel);
repositorioFilmes.Alterar(filme);
return(RedirectToAction("Index"));
}
//ViewBag.IdAlbum = new SelectList(db.Albuns, "Id", "Nome", filme.IdAlbum);
return(View(viewModel));
}
public ActionResult Edit(FilmeViewModel filmeViewModel)
{
if (ModelState.IsValid)
{
var filme = Mapper.Map <Filme>(filmeViewModel);
filmeService.Update(filme);
return(RedirectToAction("Index"));
}
return(View(filmeViewModel));
}
public async Task <ActionResult <FilmeViewModel> > Alterar(FilmeViewModel filme, int id)
{
var novoFilme = await _filmeContext.AtualizarFilme(filme, id);
if (novoFilme == null)
{
return(NotFound(new Mensagem {
mensagem = "Filme não cadastrado"
}));
}
return(Ok(filme));
}
public IActionResult Alterar([FromBody] FilmeViewModel pFilme)
{
var filme = _mapper.Map <FilmeViewModel, Filme>(pFilme);
if (filme.EhValido())
{
_filmeRepository.Atualizar(filme);
_filmeRepository.SaveChanges();
return(Response(true, filme));
}
return(Response(false, erros: filme.ValidationErrors));
}
public ActionResult Excluir(FilmeViewModel viewModel)
{
try
{
var filme = Mapper.Map <Filme>(viewModel);
_filmeService.Remove(filme);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
throw;
}
}
public ActionResult Create(FilmeViewModel filmeViewModel)
{
TempData.Keep();
if (ModelState.IsValid)
{
var filme = Mapper.Map <Filme>(filmeViewModel);
filmeService.Add(filme);
return(RedirectToAction("Index"));
}
return(View(filmeViewModel));
}
public async Task <FilmeViewModel> AtualizarFilme(FilmeViewModel filme, int id)
{
var novoFilme = await _context.Filmes.FindAsync(id);
if (novoFilme == null)
{
return(null);
}
novoFilme = filme.Atualizar(novoFilme);
await _context.SaveChangesAsync();
return(filme);
}
public ActionResult Edit(FilmeViewModel filmeVm)
{
if (ModelState.IsValid)
{
SetAuditableEntityProperties.UpdateAuditableProperties(filmeVm, currentUser: CurrentUserAsString());
var filme = Mapper.Map <FilmeViewModel, Filme>(filmeVm);
_unitOfWork.Filmes.SetModifiedState(filme);
_unitOfWork.Complete();
return(RedirectToAction("Index"));
}
filmeVm.GeneroSL = _unitOfWork.Filmes.GetGenresSL();
ViewBag.Title = "Alterar cadastro de filme";
return(View("FilmesEditForm", filmeVm));
}
// Lista de Filmes
public async Task <IActionResult> Index(bool?criterio)
{
var usuarioLogado = await _userManager.GetUserAsync(User);
var filmes = await _filmeService.GetItemAsync(criterio, usuarioLogado);
var model = new FilmeViewModel();
{
model.filmes = filmes;
}
return(View(model));
}
public IActionResult Upsert(FilmeViewModel filme)
{
Filme filmeInserir = new()
{
Id = filme.Id,
Ativo = filme.Ativo,
Ano = filme.Ano,
Diretor = filme.Diretor,
Elenco = filme.Elenco,
Pais = filme.Pais,
Titulo = filme.Titulo,
Sinopse = filme.Sinopse,
ImagemURL = filme.ImagemURL
};
if (filme.ImagemUpload != null)
{
var imgPrefixo = Guid.NewGuid() + "_";
if (!Util.Util.UploadArquivo(filme.ImagemUpload, imgPrefixo))
{
return(View(filme));
}
filmeInserir.ImagemURL = imgPrefixo + filme.ImagemUpload.FileName;
}
if (filmeInserir.ImagemURL == null)
{
filmeInserir.ImagemURL = "50bc7e78-0857-4000-a890-dafe2cd74c83_unnamed.jpg";
}
if (ModelState.IsValid)
{
if (filme.Titulo == null)
{
//Creating
_db.Filmes.Add(filmeInserir);
}
else
{
//updating
_db.Filmes.Update(filmeInserir);
}
_db.SaveChanges();
StatusMessage = "Filme cadastrado com sucesso!\n Pendente aprovação do Administrador.";
}
return(LocalRedirect($"~/Filmes/Details/{filmeInserir.Id}"));
}
public async Task <JsonResult> IncluirFilme(FilmeViewModel filme)
{
try
{
try
{
ClientService client = new ClientService();
if (filme.Arquivo != null)
{
FilmeViewModel foto = SalvarImagem(filme.Arquivo);
filme.Imagem = foto.Imagem;
filme.Caminho = foto.Caminho;
}
filme.IdUsuario = User.Claims.Where(s => s.Type == "ID").Select(s => s.Value).First();
filme.Arquivo = null;
NotificacaoViewModel resultado = await client.PostAsync <FilmeViewModel>(_config["UrlApi"] + "/Filme/filme/"
, User.Claims.Where(s => s.Type == "AccessToken").Select(s => s.Value).First(), filme);
if (resultado.Erro)
{
return(Json(new JsonModel()
{
success = false, result = resultado.Resultado, message = resultado.Msg
}));
}
return(Json(new JsonModel()
{
success = true, result = resultado, message = resultado.Msg
}));
}
catch (Exception ex)
{
return(Json(new JsonModel()
{
success = false, message = ex.Message
}));
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> PostFilme(FilmeViewModel filme)
{
var retornoFilme = await _filmeAppService.Adicionar(filme);
if (!retornoFilme.ValidationResult.IsValid)
{
foreach (var item in retornoFilme.ValidationResult.Errors)
{
ModelState.AddModelError(string.Empty, item.ErrorMessage);
}
return(Conflict(ModelState.Values.Select(x => x.Errors)));
}
return(CreatedAtAction("GetFilme", new { id = retornoFilme.IdFilme }, retornoFilme));
}
public ActionResult Create(FilmeViewModel filmeVm)
{
if (ModelState.IsValid)
{
SetAuditableEntityProperties.SetFirstTimeAuditableProperties(filmeVm, CurrentUserAsString());
var mappedFilme = Mapper.Map <FilmeViewModel, Filme>(filmeVm);
_unitOfWork.Filmes.Add(mappedFilme);
_unitOfWork.Complete();
return(RedirectToAction("Index"));
}
filmeVm.GeneroSL = _unitOfWork.Filmes.GetGenresSL();
ViewBag.Title = "Novo Filme";
return(View("FilmesEditForm", filmeVm));
}
private static IList <FilmeViewModel> MontarFilmeViewModel(this IDataService dataService, IList <Filme> listaFilme)
{
IList <FilmeViewModel> listaFilmeViewModel = new List <FilmeViewModel>();
FilmeViewModel filmeViewModel;
foreach (var filme in listaFilme)
{
if (!listaFilmeViewModel.Any(f => f.Titulo == filme.Titulo && f.TipoMidia == filme.ObterTipoMidia()))
{
filmeViewModel = new FilmeViewModel(filme);
listaFilmeViewModel.Add(filmeViewModel);
}
}
return(listaFilmeViewModel.OrderBy(f => f.Titulo).ThenBy(f => f.TipoMidia).ToList());
}
public ActionResult Cadastrar()
{
var generos = PegarSelectListaGenero();
var idiomas = PegarSelectListaIdioma();
var nomedoFilme = PegarSelectListaNomedoFilme();
var view = new FilmeViewModel();
view.Generos.AddRange(generos);
view.Idiomas.AddRange(idiomas);
view.NomesdoFilme.AddRange(nomedoFilme);
filmeTemp = view;
return(View(view));
}
public ActionResult Detalhes(int id)
{
try
{
var userSession = HttpContext.Session.GetUsuario();
if (userSession == null)
{
RedirectToAction("Index", "Login");
}
var filmeRequest = _filmeApplication.Get(userSession.Token, id);
if (!filmeRequest.IsSuccessStatusCode)
{
if (filmeRequest.StatusCode == HttpStatusCode.Unauthorized)
{
return(RedirectToAction("Index", "Login"));
}
return(Error(filmeRequest.Content.ReadAsStringAsync().Result, "_Detalhes"));
}
var filmeResponse = JsonConvert.DeserializeObject <Filme>(filmeRequest.Content.ReadAsStringAsync().Result);
var filme = new FilmeViewModel
{
FilmeId = filmeResponse.FilmeId,
Nome = filmeResponse.Nome,
Descricao = filmeResponse.Descricao,
Categoria = new CategoriaViewModel
{
CategoriaId = filmeResponse.Categoria.CategoriaId,
Nome = filmeResponse.Categoria.Nome
},
CadastroUsuarioId = filmeResponse.CadastroUsuarioId,
DataCadastro = filmeResponse.DataCadastro,
AlteracaoUsuarioId = filmeResponse.AlteracaoUsuarioId,
DataAlteracao = filmeResponse.DataAlteracao,
Ativo = filmeResponse.Ativo,
};
return(View("_Detalhes", filme));
}
catch (Exception e)
{
ModelState.AddModelError("Error", "Ocorreu um erro inesperado");
return(View("_Detalhes"));
}
}
public ActionResult Editar(FilmeViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
var filme = Mapper.Map <Filme>(viewModel);
_filmeService.Update(filme);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
throw;
}
}
return(View(viewModel));
}
public FilmeViewModel SalvarImagem(IFormFile upload)
{
try
{
if (upload != null && upload.Length > 0)
{
// Verifica a existencia do diretório
if (!Directory.Exists(Path.GetFullPath(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images"))))
{
Directory.CreateDirectory(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "images"));
}
// Nome da imagem que será salva no banco de dados
var nomeFoto = Convert.ToString(Guid.NewGuid() + "_" + upload.FileName.Replace(" ", "").Trim());
// Recuperando a configuração do arquivo appsettings de ontem será salvo o físico
string configuracaoCaminho = _config.GetValue <string>("PathImages");
// Caminho do diretório
var caminho = Path.Combine(configuracaoCaminho);
var caminhoCompleto = Path.Combine(caminho, nomeFoto);
using (Stream stream = new FileStream(caminhoCompleto, FileMode.Create))
{
upload.CopyToAsync(stream);
}
FilmeViewModel filme = new FilmeViewModel
{
Imagem = nomeFoto,
Caminho = caminho,
};
return(filme);
}
else
{
return(null);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Criar(FilmeViewModel viewModel)
{
if (!ModelState.IsValid)
{
ViewBag.Generos = new SelectList(_dbContext.Genero.OrderBy(g => g.Descricao).ToList(), "Id", "Descricao", viewModel.Filme.GeneroId);
return(View("MostrarNovo", viewModel));
}
var filmeModel = new Filme();
viewModel.Filme.Id = Guid.NewGuid();
filmeModel = viewModel.Filme;
_dbContext.Filmes.Add(filmeModel);
_dbContext.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult MostrarDetalhe(Guid?id)
{
if (id == Guid.Empty || id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Parametro Inválido."));
}
var filme = _dbContext.Filmes.Include(f => f.Genero).SingleOrDefault(fs => fs.Id == id.Value);
if (filme == null)
{
return(HttpNotFound());
}
var viewModel = new FilmeViewModel(filme);
return(View(viewModel));
}
public ActionResult Cadastrar(FilmeViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
viewModel.DataCriacao = DateTime.Now;
var filme = Mapper.Map <Filme>(viewModel);
_filmeService.Add(filme);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
throw;
}
}
return(View(viewModel));
}
public ActionResult Create([Bind(Include = "IdFilme,NomeFilme,IdAlbum")] FilmeViewModel viewModel)
{
if (ModelState.IsValid)
{
Filme filme = Mapper.Map <FilmeViewModel, Filme>(viewModel);
repositorioFilmes.Inserir(filme);
return(RedirectToAction("Index"));
}
//ViewBag.IdAlbum = new SelectList(repositorioAlbuns.Selecionar(), "IdAlbum", "Nome", viewModel.IdAlbum);
List <AlbumIndexViewModel> albuns = Mapper.Map <List <Album>,
List <AlbumIndexViewModel> >(repositorioAlbuns.Selecionar());
SelectList dropDownAlbuns = new SelectList(albuns, "Id", "Nome");
ViewBag.DropDownAlbuns = dropDownAlbuns;
return(View(viewModel));
}
