Beispiel #1
0
        /// <summary>
        /// Przesyła model danych <see cref="Models.Komorka"/> do zaktualizowania w aplikacji.
        /// </summary>
        /// <returns>Przekierowanie do listy komórek kontrolowanych.</returns>
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            _context.Attach(Komorka).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!KomorkaExists(Komorka.Id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            Log
            .ForContext("UserId", int.Parse(User.Claims.FirstOrDefault(u => u.Type.EndsWith("nameidentifier")).Value))
            .ForContext("Table", Komorka.GetType().Name)
            .ForContext("RecordId", Komorka.Id)
            .Warning("Zapisanie edycji komórki {Nazwa}.", Komorka.Nazwa);

            return(RedirectToPage("./Index"));
        }
Beispiel #2
0
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for
        // more details see https://aka.ms/RazorPagesCRUD.
        /// <summary>
        /// Dodaje nieprawidłowość i przypisuje ją do kontroli.
        /// </summary>
        /// <returns>Przekierowanie do listy kontroli.</returns>
        public async Task<IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                ViewData["KontrolaId"] = Nieprawidlowosc.KontrolaId;

                return Page();
            }

            _context.Nieprawidlowosc.Add(Nieprawidlowosc);
            await _context.SaveChangesAsync();

            Log
                .ForContext("UserId", int.Parse(User.Claims.FirstOrDefault(u => u.Type.EndsWith("nameidentifier")).Value))
                .ForContext("Table", nameof(Kontrola))
                .ForContext("RecordId", Nieprawidlowosc.Id)
                .ForContext("MainRecordId", Nieprawidlowosc.KontrolaId)
                .Warning("Dodanie nieprawidłowości.");

            var kontrola = await _context.Kontrola.FirstOrDefaultAsync(m => m.Id == Nieprawidlowosc.KontrolaId);

            if (kontrola.StatusId != 43)
            {
                kontrola.StatusId = 43;

                _context.Attach(kontrola).State = EntityState.Modified;
                await _context.SaveChangesAsync();

                Log
                    .ForContext("UserId", int.Parse(User.Claims.FirstOrDefault(u => u.Type.EndsWith("nameidentifier")).Value))
                    .ForContext("Table", kontrola.GetType().Name)
                    .ForContext("RecordId", kontrola.Id)
                    .ForContext("MainRecordId", kontrola.Id)
                    .Warning("Zmiana statusu kontroli {Numer}.", kontrola.Numer);
            }

            ViewData["KontrolaId"] = Nieprawidlowosc.KontrolaId;
            ViewData["Title"] = "Kontrola zewnętrzna - nowa nieprawidłowość/zalecenie";

            return Page();
        }
Beispiel #3
0
        /// <summary>
        /// Metoda do zmiany statusu kontroli.
        /// </summary>
        /// <param name="kontrolaId">Identyfikator kontroli.</param>
        /// <returns></returns>
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            var kontrola = await _context.Kontrola.FirstOrDefaultAsync(m => m.Id == KontrolaId);

            kontrola.StatusId = NewStatusId;
            kontrola.UwagiKW  = UwagiKW;

            _context.Attach(kontrola).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!StatusExists(NewStatusId))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            Log
            .ForContext("UserId", int.Parse(User.Claims.FirstOrDefault(u => u.Type.EndsWith("nameidentifier")).Value))
            .ForContext("Table", kontrola.GetType().Name)
            .ForContext("RecordId", kontrola.Id)
            .ForContext("MainRecordId", kontrola.Id)
            .Warning("Zmiana statusu kontroli {Numer}.", kontrola.Numer);

            return(RedirectToPage("./Details", new { id = kontrola.Id }));
        }
Beispiel #4
0
        /// <summary>
        /// Przesyła model danych <see cref="Models.Nieprawidlowosc"/> do zaktualizowania w aplikacji.
        /// </summary>
        /// <returns>Przekierowanie do strony edycji kontroli.</returns>
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                return(Page());
            }

            var old = _context.Nieprawidlowosc.AsNoTracking().FirstOrDefault(n => n.Id == Nieprawidlowosc.Id);

            _context.Attach(Nieprawidlowosc).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!NieprawidlowoscExists(Nieprawidlowosc.Id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            Log
            .ForContext("UserId", int.Parse(User.Claims.FirstOrDefault(u => u.Type.EndsWith("nameidentifier")).Value))
            .ForContext("Table", Nieprawidlowosc.GetType().Name)
            .ForContext("RecordId", Nieprawidlowosc.Id)
            .ForContext("MainRecordId", Nieprawidlowosc.KontrolaId)
            .ForContext("Old", JsonSerializer.Serialize(old))
            .ForContext("New", JsonSerializer.Serialize(Nieprawidlowosc))
            .Warning("Zapisanie edycji nieprawidłowości.");

            return(RedirectToPage("./Edit", new { id = Nieprawidlowosc.KontrolaId }));
        }
Beispiel #5
0
        /// <summary>
        /// Przesyła model danych <see cref="Models.Uzytkownik"/> do zaktualizowania w aplikacji.
        /// </summary>
        /// <returns>Przekierowanie do listy użytkowników.</returns>
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                ViewData["JednostkaId"]         = new SelectList(_context.JednostkaKontrolowana, "Id", "Nazwa");
                ViewData["KomorkaId"]           = new SelectList(_context.Komorka.OrderBy(k => k.Nazwa), "Id", "Nazwa");
                ViewData["PoziomUzytkownikaId"] = new SelectList(_context.SlownikPoziomUzytkownika, "Id", "Nazwa");

                return(Page());
            }

            _context.Attach(Uzytkownik).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UzytkownikExists(Uzytkownik.Id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            Log
            .ForContext("UserId", int.Parse(User.Claims.FirstOrDefault(u => u.Type.EndsWith("nameidentifier")).Value))
            .ForContext("Table", Uzytkownik.GetType().Name)
            .ForContext("RecordId", Uzytkownik.Id)
            .Warning("Zapisanie edycji użytkownika {Login}.", Uzytkownik.Login);

            return(RedirectToPage("./Index"));
        }
Beispiel #6
0
        /// <summary>
        /// Przesyła model danych <see cref="Models.JednostkaKontrolowana"/> do zaktualizowania w aplikacji.
        /// </summary>
        /// <returns>Przekierowanie do listy jednostek kontrolowanych.</returns>
        public async Task <IActionResult> OnPostAsync()
        {
            if (!ModelState.IsValid)
            {
                ViewData["ProcesId"] = new SelectList(_context.SlownikProces, "Id", "Nazwa");
                ViewData["KomorkaMerytorycznaId"] = new SelectList(_context.Komorka, "Id", "Nazwa");

                return(Page());
            }

            _context.Attach(JednostkaKontrolowana).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!JednostkaKontrolowanaExists(JednostkaKontrolowana.Id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            Log
            .ForContext("UserId", int.Parse(User.Claims.FirstOrDefault(u => u.Type.EndsWith("nameidentifier")).Value))
            .ForContext("Table", JednostkaKontrolowana.GetType().Name)
            .ForContext("RecordId", JednostkaKontrolowana.Id)
            .Warning("Zapisanie edycji jednostki kontrolowanej {Nazwa}.", JednostkaKontrolowana.Nazwa);

            return(RedirectToPage("./Index"));
        }
Beispiel #7
0
        /// <summary>
        /// Przesyła model danych <see cref="Models.Kontrola"/> do zaktualizowania w aplikacji.
        /// </summary>
        /// <returns>Przekierowanie do szczegółów kontroli.</returns>
        public async Task <IActionResult> OnPostAsync()
        {
            var old = _context.Kontrola.Include(k => k.Nieprawidlowosci).AsNoTracking().FirstOrDefault(k => k.Id == Kontrola.Id);

            if (Kontrola.StatusId == 43 && old.Nieprawidlowosci.Count == 0)
            {
                ModelState.AddModelError(string.Empty, "Zanim zmienisz status kontroli na Działania naprawcze dodaj najpierw nieprawidłowości/zalecenia.");
            }

            if (!ModelState.IsValid)
            {
                Kontrola = await _context.Kontrola
                           .Include(k => k.JednostkaKontrolowana)
                           .Include(k => k.JednostkaKontrolujaca)
                           .Include(k => k.KomorkaWiodaca)
                           .Include(k => k.KomorkiUczestniczace).ThenInclude(k => k.Komorka)
                           .Include(k => k.Nieprawidlowosci)
                           .Include(k => k.Status)
                           .Include(k => k.TypKontroli)
                           .Include(k => k.Zalaczniki)
                           .Include(k => k.Procesy).ThenInclude(k => k.Proces)
                           .FirstOrDefaultAsync(m => m.Id == Kontrola.Id);

                if (Kontrola.StatusId == 17 || Kontrola.StatusId == 43)
                {
                    ViewData["StatusId"] = new SelectList(_context.SlownikStatusKontroli.Where(s => s.Id == 17 || s.Id == 40 || s.Id == 43), "Id", "Nazwa");
                }
                else
                {
                    ViewData["StatusId"] = new SelectList(_context.SlownikStatusKontroli.Where(s => s.Id == 40 || s.Id == 42 || s.Id == 43), "Id", "Nazwa");
                }

                return(Page());
            }

            _context.Attach(Kontrola).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!KontrolaExists(Kontrola.Id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            Log
            .ForContext("UserId", int.Parse(User.Claims.FirstOrDefault(u => u.Type.EndsWith("nameidentifier")).Value))
            .ForContext("Table", Kontrola.GetType().Name)
            .ForContext("RecordId", Kontrola.Id)
            .ForContext("MainRecordId", Kontrola.Id)
            .ForContext("Old", JsonSerializer.Serialize(old))
            .ForContext("New", JsonSerializer.Serialize(Kontrola))
            .Warning("Zapisanie edycji kontroli {Numer}.", Kontrola.Numer);

            return(RedirectToPage("./Details", new { id = Kontrola.Id }));
        }