public async Task <IActionResult> Create([Bind("Id,CinemaFK,MovieFK,Start,End,Occupated_seats")] Sessions session)
{
if (ModelState.IsValid)
{
//verifica se existe alguma sessao no mesmo cinema entre a data da nova sessao
if (await _context.Sessions.Where(s => session.Start >= s.Start && session.Start <= s.End && s.Cinema.Id == session.CinemaFK).AnyAsync())
{
ViewData["message"] = "Já existe uma sessão neste cinema entre esta data.";
ViewData["CinemaFK"] = new SelectList(_context.Cinemas, "Id", "Name", session.CinemaFK);
ViewData["MovieFK"] = new SelectList(_context.Movies, "Id", "Name", session.MovieFK);
return(View());
}
session.End = session.Start; //fim=inicio
session.End = session.End.AddMinutes(_context.Movies.Find(session.MovieFK).Duration); //fim+duração do filme
_context.Add(session);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["CinemaFK"] = new SelectList(_context.Cinemas, "Id", "Name", session.CinemaFK);
ViewData["MovieFK"] = new SelectList(_context.Movies, "Id", "Name", session.MovieFK);
return(View(session));
}
public async Task <IActionResult> Create([Bind("Name,Capacity,City,Location")] Cinemas cinema)
{
if (ModelState.IsValid)
{
if (_context.Cinemas.Where(c => c.Name == cinema.Name).Any())//verifica se existe algum cinema com o mesmo nome
{
ViewData["message"] = "Já existe um cinema com o mesmo nome.";
return(View(cinema));
}
//adiciona o utilizador
_context.Add(cinema);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cinema));
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
RequirePassword = await _userManager.HasPasswordAsync(user);
if (RequirePassword)
{
if (!await _userManager.CheckPasswordAsync(user, Input.Password))
{
ModelState.AddModelError(string.Empty, "Incorrect password.");
return(Page());
}
}
var result = await _userManager.DeleteAsync(user);
var userId = await _userManager.GetUserIdAsync(user);
if (!result.Succeeded)
{
throw new InvalidOperationException($"Unexpected error occurred deleting user with ID '{userId}'.");
}
var dbUser = _context.User.Find(user.User);
foreach (var item in dbUser.TicketsList) //apaga os bilhetes
{
dbUser.TicketsList.Remove(item);
if (item.Session.Start.Ticks > DateTime.Now.Ticks)
{
item.Session.Occupated_seats -= 1;
}
}
_context.User.Remove(dbUser); //apaga o utilizador
if (dbUser.Avatar != "default.png")
{
System.IO.File.Delete(_environment.WebRootPath + "/images/users/" + dbUser.Avatar); // apaga a fotografia
}
await _context.SaveChangesAsync();
await _signInManager.SignOutAsync();
_logger.LogInformation("User with ID '{UserId}' deleted themselves.", userId);
return(Redirect("~/"));
}
public async Task <IActionResult> Create([Bind("Id,Name,Description,Genres,Duration,Min_age,Highlighted")] Movies movie, IFormFile Poster)
{
if (ModelState.IsValid)
{
if (_context.Movies.Where(m => m.Name == movie.Name).Any())//verifica se existe algum filme com o mesmo nome
{
ViewData["message"] = "Já existe um filme com o mesmo nome.";
return(View(movie));
}
//se o poster não fôr imagem usa-se a imagem default
if (Poster == null || !Poster.ContentType.Contains("image"))
{
movie.Poster = "default.png";
}
else
{ //usa a imagem recebida
Guid g;
g = Guid.NewGuid();
string extensao = Path.GetExtension(Poster.FileName).ToLower();
// caminho do ficheiro
movie.Poster = g.ToString() + extensao;
//guarda a imagem
using var fileStream = new FileStream(_environment.WebRootPath + "/images/movies/" + g.ToString() + extensao, FileMode.Create);
await Poster.CopyToAsync(fileStream);
}
//adiciona o filme ----------------------
_context.Add(movie);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(movie));
}
public async Task <IActionResult> OnGetAsync(string userId, string code)
{
if (userId == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound($"Não foi possivel encontrar o utilizador com o ID '{userId}'."));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ConfirmEmailAsync(user, code);
if (result.Succeeded)
{
StatusMessage = "Obrigado por confirmar o seu email.";
await _userManager.SetUserNameAsync(user, await _userManager.GetEmailAsync(user));
await _userManager.UpdateAsync(user);
var bdUser = _context.User.Find(user.User);
bdUser.Email = await _userManager.GetEmailAsync(user);
await _context.SaveChangesAsync();
}
else
{
StatusMessage = "Erro ao confirmar o email.";
}
return(Page());
}
public async Task <IActionResult> Edit(int Id, string Email, string Name, DateTime DoB, string Role, IFormFile Avatar)
{
var user = _context.User.Find(Id);
if (user == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
if (_context.User.Where(u => u.Email == Email && u.Id != Id).Any())//verifica se existe algum utilizador com o mesmo email
{
ViewData["message"] = "Já existe um utilizador com o mesmo email.";
return(View(_context.User.Find(Id)));
}
try
{
//verifica se o avatar mudou
if (Avatar == null)
{
} //não muda a imagem
else if (!Avatar.ContentType.Contains("image")) //se o poster não fôr imagem usa-se a imagem default
{
//apaga a antiga imagem
if (user.Avatar != "default.png")
{
System.IO.File.Delete(_environment.WebRootPath + "/images/users/" + user.Avatar);
}
//guarda a nova imagem
user.Avatar = "default.png";
}
else
{ //update atualiza a imagem
//apaga o antigo poster excepto se for o poster default
if (user.Avatar != "default.png")
{
System.IO.File.Delete(_environment.WebRootPath + "/images/users/" + user.Avatar);
}
Guid g;
g = Guid.NewGuid();
string extensao = Path.GetExtension(Avatar.FileName).ToLower();
// caminho do ficheiro
user.Avatar = g.ToString() + extensao;
//guarda a imagem
using var fileStream = new FileStream(_environment.WebRootPath + "/images/users/" + g.ToString() + extensao, FileMode.Create);
await Avatar.CopyToAsync(fileStream);
}
//altera os dados do utilizador
user.Email = Email;
user.Name = Name;
user.DoB = DoB;
user.Role = Role;
_context.Update(user);
//altera os dados do application user
var netUser = await _context.Users.Where(u => u.User == Id).FirstOrDefaultAsync();
netUser.UserName = Email;
netUser.Email = Email;
netUser.Nome = Name;
//altera o cargo dependendo da opcao escolhida
var userRole = await _context.UserRoles.Where(uR => uR.UserId == netUser.Id).FirstOrDefaultAsync();
if (userRole.RoleId == "1" && Role == "User") //remove Admin e dá User
{
await _userManager.RemoveFromRoleAsync(netUser, "Admin");
await _userManager.AddToRoleAsync(netUser, "User");
}
else if (userRole.RoleId == "2" && Role == "Admin") // remove User e dá Admin
{
await _userManager.RemoveFromRoleAsync(netUser, "User");
await _userManager.AddToRoleAsync(netUser, "Admin");
}
await _userManager.UpdateAsync(netUser); //edita o application user com os novos dados
_context.Update(userRole);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsersExists(Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
List <SelectListItem> list = new List <SelectListItem> {
new SelectListItem()
{
Text = "User", Value = "User"
},
new SelectListItem()
{
Text = "Admin", Value = "Admin"
}
};
ViewData["Roles"] = new SelectList(list, "Value", "Text");
return(View(user));
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
//verifica se o email ja esta a ser utilizado
if (_context.User.Where(u => u.Email == Input.Email).Any())
{
ModelState.AddModelError(string.Empty, "Este Email já está a ser utilizado.");
}
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
Users user = new Users //cria o utilizador usado nas relações
{
Name = Input.Nome,
Email = Input.Email,
DoB = Input.DoB,
Role = "User",
Avatar = "default.png",
};
_context.Add(user);
await _context.SaveChangesAsync();
var applicationUser = new ApplicationUser //cria application User
{
UserName = Input.Email,
Email = Input.Email,
Nome = Input.Nome,
Timestamp = DateTime.Now,
User = user.Id //id do utilizador
};
var result = await _userManager.CreateAsync(applicationUser, Input.Password); //adiciona o application user
if (result.Succeeded)
{
//dar permissão ao Application User com a permissão base: User
await _userManager.AddToRoleAsync(applicationUser, "User");
_logger.LogInformation("Utilizador criado.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(applicationUser);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = applicationUser.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirme o seu email",
$"Por favor confirme o seu email ao <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicar aqui</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(applicationUser, 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> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, set lockoutOnFailure: true
var result = await _signInManager.PasswordSignInAsync(Input.Email, Input.Password, Input.RememberMe, lockoutOnFailure : false);
Console.WriteLine(result);
if (result.Succeeded)
{
_logger.LogInformation("User logged in.");
return(LocalRedirect(returnUrl));
}
if (result.RequiresTwoFactor)
{
return(RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = Input.RememberMe }));
}
if (result.IsLockedOut) // o utilizador tem a conta bloqueada
{
_logger.LogWarning("User account locked out.");
//apaga o utilizador ----------------------------
var user = _context.Users.Where(u => u.UserName == Input.Email).FirstOrDefault();
var result2 = await _userManager.DeleteAsync(user); //apaga o application user
var userId = await _userManager.GetUserIdAsync(user); //procura o id do user
if (!result2.Succeeded)
{
throw new InvalidOperationException($"Unexpected error occurred deleting user with ID '{userId}'.");
}
var dbUser = _context.User.Find(user.User); // procura o utilizador associado ao application user
foreach (var item in dbUser.TicketsList) //apaga os bilhetes de cada sessao associada ao utilizador
{
dbUser.TicketsList.Remove(item);
if (item.Session.Start.Ticks > DateTime.Now.Ticks)
{
item.Session.Occupated_seats -= 1; //retira o bilhete da sessao
}
}
_context.User.Remove(dbUser); //apaga o utilizador usado nas relacoes
if (dbUser.Avatar != "default.png")
{
System.IO.File.Delete(_environment.WebRootPath + "/images/users/" + dbUser.Avatar); // apaga a fotografia
}
await _context.SaveChangesAsync();
_logger.LogInformation("User with ID '{UserId}' was deleted.", userId);
//----------------------------------------
return(RedirectToPage("./Lockout"));
}
else
{
ModelState.AddModelError(string.Empty, "Tentativa inválida.");
return(Page());
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> Create(int SessionFK)
{
var session = _context.Sessions.Find(SessionFK);
if (session == null)
{
return(RedirectToAction("Index", "Home"));
}
//obtem o application user atual
var applicationUser = await _userManager.GetUserAsync(User);
//obtem o utilizador associado ao application user atual
var user = _context.User.Where(u => u.Id == applicationUser.User).FirstOrDefault();
ViewData["User"] = user.Id;//envia para a view o id do user
//filme da sessao escolhida pelo utilizador
var movie = await _context.Movies.Where(m => m.Id == session.MovieFK).FirstOrDefaultAsync();
//a sessão já começou
var now = new DateTime().Ticks;
if (now >= session.Start.Ticks && now <= session.End.Ticks)
{
TempData["Message"] = "Esta sessão já está a decorrer.";
return(Redirect("~/Movies/Details/" + movie.Id));
}
//o utilizador já tem o bilhete
if (_context.Tickets.Where(t => t.Session == session && t.Id == applicationUser.User).Any())
{
TempData["Message"] = "Já possui o bilhete para esta sessão.";
return(Redirect("~/Movies/Details/" + movie.Id));
}
//capacidade cheia
if (session.Occupated_seats >= _context.Cinemas.Find(session.CinemaFK).Capacity)
{
TempData["Message"] = "Filme com capacidade esgotada. Atualize a página.";
return(Redirect("~/Movies/Details/" + movie.Id));
}
//sem idade para comprar o bilhete
if (DateTime.Now.Ticks < user.DoB.AddYears(session.Movie.Min_age).Ticks)
{
TempData["Message"] = "Não tem idade para comprar o bilhete para este filme.";
return(Redirect("~/Movies/Details/" + movie.Id));
}
try
{//compra o bilhete
Tickets ticket = new Tickets
{
SessionFK = SessionFK,
UserFK = _context.User.Where(u => u.Id == applicationUser.User).Select(u => u.Id).FirstOrDefault(),
Seat = session.Occupated_seats + 1
};
session.Occupated_seats += 1;//incrementa o numero de lugares ocupados na sessao
_context.Add(ticket);
await _context.SaveChangesAsync();
return(Redirect("~/Movies/Details/" + movie.Id));
}
catch (Exception)
{
TempData["Message"] = "Erro inesperado.";
return(Redirect("~/Movies/Details/" + movie.Id));
}
}
public async Task <IActionResult> OnPostAsync()
{
var netUser = await _userManager.GetUserAsync(User);
if (netUser == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ModelState.IsValid)
{
LoadAsync(netUser);
return(Page());
}
var bdUser = await _context.User.FindAsync(netUser.User);
var file = HttpContext.Request.Form.Files.GetFile("Avatar");
//verifica se o avatar mudou
if (file == null)
{
} //não muda a imagem
else if (!file.ContentType.Contains("image")) //se o poster não fôr imagem usa-se a imagem default
{
//apaga a antiga imagem
if (bdUser.Avatar != "default.png")
{
System.IO.File.Delete(_environment.WebRootPath + "/images/users/" + bdUser.Avatar);
}
//guarda a nova imagem
bdUser.Avatar = "default.png";
}
else
{ //update atualiza a imagem
//apaga o antigo poster excepto se for o poster default
if (bdUser.Avatar != "default.png")
{
System.IO.File.Delete(_environment.WebRootPath + "/images/users/" + bdUser.Avatar);
}
Guid g;
g = Guid.NewGuid();
string extensao = Path.GetExtension(file.FileName).ToLower();
// caminho do ficheiro
bdUser.Avatar = g.ToString() + extensao;
//guarda a imagem
using var fileStream = new FileStream(_environment.WebRootPath + "/images/users/" + g.ToString() + extensao, FileMode.Create);
await file.CopyToAsync(fileStream);
}
if (Input.Nome != netUser.Nome) //atualiza o nome
{
netUser.Nome = Input.Nome;
}
if (Input.DoB != bdUser.DoB) //atualiza a data de nascimento
{
bdUser.DoB = Input.DoB;
}
_context.Update(bdUser); //atualiza a imagem
await _userManager.UpdateAsync(netUser);
await _context.SaveChangesAsync();
await _signInManager.RefreshSignInAsync(netUser);
StatusMessage = "O seu perfil foi atualizado.";
return(RedirectToPage());
}