public async Task <IActionResult> Create([Bind("Id,Tarefa")] Profissao profissao)
{
if (ModelState.IsValid)
{
_context.Add(profissao);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(profissao));
}
public async Task <IActionResult> Create([Bind("Id,Nome")] Genero genero)
{
if (ModelState.IsValid)
{
_context.Add(genero);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(genero));
}
public async Task <IActionResult> Create([Bind("Id,Premio,FilmeFK,PessoaFK")] PessoaFilme pessoaFilme)
{
if (ModelState.IsValid)
{
_context.Add(pessoaFilme);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["FilmeFK"] = new SelectList(_context.Filme, "Id", "Titulo", pessoaFilme.FilmeFK);
ViewData["PessoaFK"] = new SelectList(_context.Pessoa, "Id", "Nome", pessoaFilme.PessoaFK);
return(RedirectToAction("Index", "Filmes"));
}
public async Task <IActionResult> Create([Bind("Id,FilmeFK,GeneroFK")] FilmeGenero filmeGenero)
{
if (ModelState.IsValid)
{
_context.Add(filmeGenero);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["FilmeFK"] = new SelectList(_context.Filme, "Id", "Titulo", filmeGenero.FilmeFK);
ViewData["GeneroFK"] = new SelectList(_context.Genero, "Id", "Nome", filmeGenero.GeneroFK);
return(View(filmeGenero));
}
public async Task <IActionResult> Create([Bind("Id,Estado,UtilIdFK,FilFK")] UtilFilme utilFilme)
{
utilFilme.UtilIdFK = _userManager.GetUserId(User);
if (ModelState.IsValid)
{
_context.Add(utilFilme);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["FilFK"] = new SelectList(_context.Filme, "Id", "Titulo", utilFilme.FilFK);
return(View(utilFilme));
}
public async Task CreateGestorAsync(WatchListDbContext context, UserManager <ApplicationUser> userManager)
{
const string nome = "gestor";
const string email = "*****@*****.**";
const string password = "******";
var user = new ApplicationUser
{
UserName = email,
Email = email,
DataRegisto = DateTime.Now,
EmailConfirmed = true, // o email está confirmado
};
if (!userManager.Users.Contains <ApplicationUser>(user))
{
var util = new Watch_List.Models.Utilizador
{
Email = email,
Id = 1,
Nome = nome,
UtilIdFK = user.Id,
};
var result = await userManager.CreateAsync(user, password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, "Gestor");
}
context.Add(context.Utilizador); // adicionar o utilizador
await context.SaveChangesAsync();
}
}
public async Task <IActionResult> Create([Bind("Id,Nome,Foto,DataNasc,DataObi,DataInic,Nacionalidade,ProfissaoFK")] Pessoa pessoa, IFormFile imagem)
{
if (pessoa.ProfissaoFK < 0)
{
// não foi escolhido uma profissao válida
ModelState.AddModelError("", "Não se esqueça de escolher uma profissão...");
// devolver o controlo à View
var profissao = (from pr in _context.Profissao
join p in _context.Pessoa on pr.Id equals p.ProfissaoFK
select pr)
.OrderBy(pr => pr.Tarefa);
ViewData["ProFK"] = new SelectList(profissao, "Id", "Tarefa");
return(View(pessoa));
}
// var auxiliar
string caminhoCompleto = "";
if (imagem == null)
{
// não há ficheiro
// adicionar msg de erro
ModelState.AddModelError("", "Adicione uma fotografia, por favor");
// devolver o controlo à View
var profissao = (from pr in _context.Profissao
join p in _context.Pessoa on pr.Id equals p.ProfissaoFK
select pr)
.OrderBy(pr => pr.Tarefa);
ViewData["ProFK"] = new SelectList(profissao, "Id", "Tarefa");
return(View(pessoa));
//pessoa.Foto = "noimage.png";
}
else
{
// há ficheiro. Mas, será um ficheiro válido?
if (imagem.ContentType == "image/jpeg" || imagem.ContentType == "image/png" || imagem.ContentType == "image/jpg")
{
// definir o novo nome da fotografia
Guid g;
g = Guid.NewGuid();
caminhoCompleto = g.ToString(); // determinar a extensão do nome da imagem
string extensao = Path.GetExtension(imagem.FileName).ToLower();
// caminho completo do ficheiro
caminhoCompleto = caminhoCompleto + extensao;
// associar este ficheiro aos dados ds foto
pessoa.Foto = caminhoCompleto;
// localização do armazenamento da imagem
string localizacaoFicheiro = _caminho.WebRootPath;
caminhoCompleto = Path.Combine(localizacaoFicheiro, "Imagens", caminhoCompleto);
}
else
{
// ficheiro não é válido
// adicionar msg de erro
ModelState.AddModelError("", "Só pode escolher uma imagem");
// devolver o controlo à View
var profissao = (from pr in _context.Profissao
join p in _context.Pessoa on pr.Id equals p.ProfissaoFK
select pr)
.OrderBy(pr => pr.Tarefa);
ViewData["ProFK"] = new SelectList(profissao, "Id", "Tarefa");
return(View(pessoa));
}
}
if (ModelState.IsValid)
{
try
{
_context.Add(pessoa);
await _context.SaveChangesAsync();
// vou guardar, agora, no disco rígido do Servidor a imagem
using var stream = new FileStream(caminhoCompleto, FileMode.Create);
await imagem.CopyToAsync(stream);
return(RedirectToAction(nameof(Index)));
}
catch (Exception)
{
ModelState.AddModelError("", "Ocorreu um erro...");
}
}
ViewData["ProFK"] = new SelectList(_context.Profissao.OrderBy(pr => pr.Tarefa), "Id", "Tarefa", pessoa.ProfissaoFK);
return(View(pessoa));
}
/// <summary>
/// criar um novo Utilizador
/// registar os dados pessoais do utilizador
/// </summary>
/// <param name="returnUrl"></param>
/// <returns></returns>
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = Input.Email,
Email = Input.Email,
DataRegisto = DateTime.Now,
EmailConfirmed = true, // o email está confirmado
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
await _userManager.AddToRoleAsync(user, "Gestor");
// //*************************************************************
// // Guardar os dados do Utilizador
// //*************************************************************
// // preparar os dados do utilizador para serem adicionados à BD
// Input.Utilizador.Email = Input.Email;
// Input.Utilizador.UtilIdFK = user.Id; // adicionar o ID do utilizador,
// // para formar uma 'ponte' (foreign key) entre
// // os dados da autenticação e os dados do 'negócio'
// // estamos em condições de guardar os dados na BD
try
{
// _context.Add(Input.Utilizador); // adicionar o utilizador
await _context.SaveChangesAsync();
// Enviar para o utilizador para a página de confirmação da criaçao de Registo
return(RedirectToPage("RegisterConfirmation"));
}
catch (Exception)
{
// Mas, o USER já foi criado na BD
// é efetuado o Roolback da ação
await _userManager.DeleteAsync(user);
// avisar que houve um erro
ModelState.AddModelError("", "Ocorreu um erro na criação de dados");
}
/*Codigo default*/
// var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
// code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
// var callbackUrl = Url.Page(
// "/Account/ConfirmEmail",
// pageHandler: null,
// values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
// protocol: Request.Scheme);
// await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
// $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// if (_userManager.Options.SignIn.RequireConfirmedAccount)
// {
// return RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl });
// }
// else
// {
// await _signInManager.SignInAsync(user, isPersistent: false);
// return LocalRedirect(returnUrl);
// }
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task<IActionResult> PutFilme(int id, [FromForm]Filme filme, IFormFile poster)
{
if (id != filme.Id)
{
return BadRequest();
}
string caminhoCompleto = "";
var deprecatedFilme = await _context.Filme.FindAsync(id);
if (poster.FileName == "null")
{
filme.Poster = deprecatedFilme.Poster;
}
else
{
// definir o novo nome da fotografia
Guid g;
g = Guid.NewGuid();
//apagar a imagem anterior
string localizacaoFicheiro = _path.WebRootPath;
caminhoCompleto = Path.Combine(localizacaoFicheiro, "Imagens", deprecatedFilme.Poster);
if (System.IO.File.Exists(caminhoCompleto))
{
System.IO.File.Delete(caminhoCompleto);
}
caminhoCompleto = g.ToString(); // determinar a extensão do nome da imagem
string extensao = Path.GetExtension(poster.FileName).ToLower();
// caminho completo do ficheiro
caminhoCompleto += extensao;
// associar este ficheiro aos dados ds foto
filme.Poster = caminhoCompleto;
// localização do armazenamento da imagem
caminhoCompleto = Path.Combine(localizacaoFicheiro, "Imagens", caminhoCompleto);
}
_context.Entry<Filme>(deprecatedFilme).State = EntityState.Detached;
try
{
_context.Entry(filme).State = EntityState.Modified;
await _context.SaveChangesAsync();
if(poster.FileName != "null")
{
using var stream = new FileStream(caminhoCompleto, FileMode.Create);
await poster.CopyToAsync(stream);
}
}
catch (DbUpdateConcurrencyException)
{
if (!FilmeExists(id))
{
return NotFound();
}
else
{
throw;
}
}
return NoContent();
}
public async Task <IActionResult> Create([Bind("Id,Titulo,Ano,Resumo,Poster,Trailer")] Filme filme, IFormFile foto)
{
string caminhoCompleto = "";
bool haImagem = false;
// avaliar se o utilizador escolheu uma opção válida na dropdown
/******************************************/
if (foto == null)
{
// não há ficheiro!
filme.Poster = "noimage.png";
}
else
{
// há ficheiro.
if (foto.ContentType == "image/jpeg" || foto.ContentType == "image/png")
{
//existe imagem
Guid g;
g = Guid.NewGuid();
// identificar a Extensão do ficheiro
string extensao = Path.GetExtension(foto.FileName).ToLower();
// nome do ficheiro
string nome = g.ToString() + extensao;
// Identificar o caminho onde o ficheiro vai ser guardado
caminhoCompleto = Path.Combine(_caminho.WebRootPath, "Imagens", nome);
// associar o nome da fotografia
filme.Poster = nome;
// assinalar que existe imagem
haImagem = true;
}
else
{
filme.Poster = "noimage.png";
}
}
if (ModelState.IsValid)
{
try {
_context.Add(filme);
await _context.SaveChangesAsync();
if (haImagem)
{
using var stream = new FileStream(caminhoCompleto, FileMode.Create);
await foto.CopyToAsync(stream);
}
// redireciona o utilizador para a View Index
return(RedirectToAction(nameof(Index)));
}
catch (Exception)
{
ModelState.AddModelError("", "Ocorreu um erro...");
}
}
ViewData["ListFilmes"] = new SelectList(_context.Filme.OrderBy(c => c.Titulo), "Id", "Titulo", foto);
return(View(filme));
}