public async Task <IActionResult> Create([Bind("Id,Title")] Film film)
        {
            if (ModelState.IsValid)
            {
                _context.Add(film);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(film));
        }
Beispiel #2
0
        public async Task <IActionResult> Create([Bind("Id,Nr,Rows,Columns")] Hall hall)
        {
            if (ModelState.IsValid)
            {
                _context.Add(hall);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(hall));
        }
Beispiel #3
0
        public async Task <IActionResult> Edit(string id, [Bind("Id,UserName,Role")] IdentityUserViewModel userVM)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                return(NotFound());
            }

            var newRole = userVM.Role;

            var role = await _roleManager.FindByNameAsync(newRole);

            if (role != null)
            {
                var user = await _userManager.FindByIdAsync(id);

                // wez role usera tego powyzej
                var prevRoleList = await _userManager.GetRolesAsync(user);

                string prevRole = prevRoleList.FirstOrDefault();
                // usun z tego usera stara role
                await _userManager.RemoveFromRoleAsync(user, prevRole);

                // mozwile ze tu bedzie trzeba savechanges ale jak nie to gituwa
                // przypisz nowa role do usera
                await _userManager.AddToRolesAsync(user, new List <string> {
                    role.Name
                });

                //update i elo
                //_context.Update(user);
                await _context.SaveChangesAsync();
            }

            //if (await _userManager.IsInRoleAsync(user, "Customer"))
            //{
            //    await _userManager.RemoveFromRoleAsync(user, "Customer");

            //    //await _context.saveChangesAsync()

            //    await _userManager.AddToRoleAsync(user, newRole);
            //}

            //_context.Update(user);
            //await _context.SaveChangesAsync();
            return(RedirectToAction(nameof(Index)));

            //return View(user);
        }
Beispiel #4
0
        public async Task <IActionResult> OnPostAsync(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            Reservation = await _context.Reservations
                          .Include(q => q.Show)
                          .ThenInclude(q => q.Film)
                          .FirstOrDefaultAsync(m => m.Id == id);

            if (Reservation != null)
            {
                _context.Reservations.Remove(Reservation);
                await _context.SaveChangesAsync();
            }

            return(RedirectToPage("./Index"));
        }
        public async Task <IActionResult> Details(int?id, int?row, int?column, int?confirmId)
        {
            if (confirmId != null)
            {
                await ConfirmReservation(confirmId);

                return(RedirectToAction(nameof(Index)));
            }

            #region ExtractConfirmed

            var allShowReservations = await _context.Reservations
                                      .Include(x => x.Show)
                                      .Where(x => x.Show.Id == id)
                                      .ToListAsync();

            var notConfirmed = allShowReservations.Where(x => !x.IsConfirmed).ToList();
            var confirmed    = allShowReservations.Where(x => x.IsConfirmed).ToList();

            var expired = notConfirmed.Where(q => DateTime.Now - q.ClickDate > expTime).ToList();

            if (expired.Any())
            {
                foreach (var r in expired)
                {
                    _context.Reservations.Remove(r);
                }
                await _context.SaveChangesAsync();
            }

            //notConfirmed = notConfirmed - expired
            notConfirmed = _context.Reservations
                           .Include(x => x.Show)
                           .Where(x => x.Show.Id == id && !x.IsConfirmed)
                           .ToList();

            TempData["notConfirmed"]  = notConfirmed;
            TempData["confirmed"]     = confirmed;
            TempData["reservationId"] = 0;
            TempData["isClicked"]     = false;

            #endregion

            if (id == null)
            {
                return(NotFound());
            }

            var userId       = User.FindFirstValue(ClaimTypes.NameIdentifier);
            var showToUpdate = await _context.Shows
                               .Include(q => q.Film)
                               .Include(p => p.Hall)
                               .FirstOrDefaultAsync(m => m.Id == id);

            if (showToUpdate == null)
            {
                return(NotFound());
            }

            if (row != null && column != null)
            {
                var resOnSeat = await _context.Reservations.FirstOrDefaultAsync(x => x.IsConfirmed == false && x.Show.Id == id && x.SeatRow == row && x.SeatColumn == column);

                if (resOnSeat != null)
                {
                    ModelState.AddModelError(string.Empty, "This seat is temporary booked. Book another seat or check its availability later.");
                }

                else
                {
                    var prevRes = await _context.Reservations.FirstOrDefaultAsync(x => x.UserId == userId && x.Show.Id == id && x.IsConfirmed == false);

                    if (prevRes != null)
                    {
                        if (await TryUpdateModelAsync <Reservation>(
                                prevRes,
                                "",
                                s => s.SeatRow, s => s.SeatColumn))
                        {
                            prevRes.SeatRow    = row;
                            prevRes.SeatColumn = column;
                            prevRes.ClickDate  = DateTime.Now;
                        }
                    }
                    else
                    {
                        Reservation res = new Reservation
                        {
                            Show        = showToUpdate,
                            SeatRow     = row,
                            SeatColumn  = column,
                            UserId      = userId,
                            ClickDate   = DateTime.Now,
                            IsConfirmed = false
                        };

                        _context.Reservations.Add(res);
                    }
                    await _context.SaveChangesAsync();

                    TempData["row"]    = row;
                    TempData["column"] = column;

                    var selected = _context.Reservations.FirstOrDefault
                                   (
                        x => x.IsConfirmed == false &&
                        x.UserId == userId &&
                        x.SeatRow == row &&
                        x.SeatColumn == column &&
                        x.Show.Id == id
                                   );
                    if (selected != null)
                    {
                        TempData["reservationId"] = selected.Id;
                    }

                    ModelState.AddModelError(string.Empty, "Confirm your reservation, otherwise it will be removed in:");
                    TempData["isClicked"] = true;
                }
            }
            return(View(showToUpdate));
        }