Ejemplo n.º 1
0
        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));
        }
Ejemplo n.º 2
0
        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("~/"));
        }
Ejemplo n.º 4
0
        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));
        }
Ejemplo n.º 5
0
        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());
        }
Ejemplo n.º 6
0
        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));
        }
Ejemplo n.º 7
0
        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());
        }
Ejemplo n.º 8
0
        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());
        }
Ejemplo n.º 9
0
        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));
            }
        }
Ejemplo n.º 10
0
        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());
        }