public async Task <IActionResult> Create([Bind("Id,Ime,Opis,Cijena,JeUkljucen,Slika,UslugeID")] Dodaci dodaci, IFormFile Slika)
{
if (ModelState.IsValid)
{
if (Slika != null)
{
if (Slika.Length > 0)
{
byte[] SlikaBitovi = null;
using (var fs1 = Slika.OpenReadStream())
using (var ms1 = new MemoryStream())
{
fs1.CopyTo(ms1);
SlikaBitovi = ms1.ToArray();
}
dodaci.Slika = SlikaBitovi;
}
}
if (dodaci.JeUkljucen)
{
dodaci.Cijena = 0;
}
_context.Add(dodaci);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "DodaciUsluge", new { id = dodaci.Id }));
}
ViewData["UslugeID"] = new SelectList(_context.Usluge, "Id", "Naziv", dodaci.UslugeID);
return(View(dodaci));
}
public async Task <IActionResult> Edit(OdrzaniCasDetaljiVM model)
{
var currentUser = await HttpContext.GetLoggedInUser();
var nastavnik = await _dbContext.Nastavnik.FirstOrDefaultAsync(x => x.UserId == currentUser.Id);
if (nastavnik == null)
{
return(NotFound());
}
var casFromDb = await _dbContext.OdrzaniCasovi
.Include(x => x.Angazovan)
.FirstOrDefaultAsync(x => x.Id == model.Id);
if (casFromDb == null)
{
return(NotFound());
}
//Provera da li je trenutno prijavljeni nastavnik kreirao cas koji se namerava izmeniti
if (casFromDb.Angazovan.NastavnikId != nastavnik.Id)
{
return(Unauthorized());
}
casFromDb.Datum = model.Datum;
_dbContext.Update(casFromDb);
await _dbContext.SaveChangesAsync();
return(Ok("Uspjesno evidentiran datum odrzanog casa."));
}
public async Task <ActionResult <Korisnik> > GetBrojTelefona(int id, Korisnik korisnik)
{
if (id != 0)
{
_context.Entry(korisnik).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(korisnik);
}
if (korisnik.Ime != null)
{
_context.korisnici.Add(korisnik);
await _context.SaveChangesAsync();
return(korisnik);
}
else
{
Korisnik user = _context.korisnici.Where(i => i.BrojTelefona == korisnik.BrojTelefona && i.Lozinka == korisnik.Lozinka).FirstOrDefault();
if (user != null)
{
return(user);
}
else
{
return(Unauthorized());
}
}
}
public async Task <IActionResult> Create([Bind("Id,Kapacitet,Naziv,Opis")] TipSobe tipSobe)
{
if (ModelState.IsValid)
{
_context.Add(tipSobe);
await _context.SaveChangesAsync();
List <TipSobeNamjestaj> nova = new List <TipSobeNamjestaj>();
foreach (Namjestaj.TipNamjestaja val in Enum.GetValues(typeof(Namjestaj.TipNamjestaja)))
{
nova.Add(new TipSobeNamjestaj()
{
TipNamjestaja = val,
Kolicina = tipSobe.Kapacitet,
TipSobeID = tipSobe.Id
});
}
_context.TipSobeNamjestaj.AddRange(nova);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
return(View(tipSobe));
}
public async Task <IActionResult> Create([Bind("Id,Ime,Opis,Cijena,JeOsnovniNamjestaj,tipNamjestaja,Slika")] Namjestaj namjestaj, IFormFile Slika)
{
if (ModelState.IsValid)
{
if (Slika != null)
{
if (Slika.Length > 0)
{
byte[] SlikaBitovi = null;
using (var fs1 = Slika.OpenReadStream())
using (var ms1 = new MemoryStream())
{
fs1.CopyTo(ms1);
SlikaBitovi = ms1.ToArray();
}
namjestaj.Slika = SlikaBitovi;
}
}
if (namjestaj.JeOsnovniNamjestaj)
{
namjestaj.Cijena = 0;
}
_context.Add(namjestaj);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "Namjestaj", new { id = namjestaj.Id }));
}
return(View(namjestaj));
}
public async Task <IActionResult> Create([Bind("Id,Naziv,Opis,Cijena,TipCijene,TipUsluge")] Usluge usluge, IFormFile Slika)
{
if (ModelState.IsValid)
{
if (Slika != null)
{
if (Slika.Length > 0)
{
byte[] SlikaBitovi = null;
using (var fs1 = Slika.OpenReadStream())
using (var ms1 = new MemoryStream())
{
fs1.CopyTo(ms1);
SlikaBitovi = ms1.ToArray();
}
usluge.Slika = SlikaBitovi;
}
}
if (usluge.TipCijene == 0)
{
usluge.Cijena = 0;
}
_context.Add(usluge);
await _context.SaveChangesAsync();
return(RedirectToAction("Details", "Usluge", new { id = usluge.Id }));
}
return(View(usluge));
}
public async Task <IActionResult> Uredi(MaturskiIspitStavkaInputVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Podaci nisu validni."));
}
var polaganje = await _dbContext.MaturskiIspitStavke
.Include(x => x.UpisUOdjeljenje)
.ThenInclude(x => x.Ucenik)
.FirstOrDefaultAsync(x => x.Id == model.Id);
if (polaganje == null)
{
return(NotFound());
}
if (polaganje.Oslobodjen)
{
return(BadRequest());
}
polaganje.Bodovi = model.Bodovi;
_dbContext.Update(polaganje);
await _dbContext.SaveChangesAsync();
return(PartialView("_MaturskiIspitStavkaRow", await BuildMaturskiIspitStavkaVM(polaganje)));
}
public async Task <bool> Dodaj(OdrzaniCas cas)
{
if (cas == null)
{
return(false);
}
try
{
await _dbContext.AddAsync(cas);
await _dbContext.SaveChangesAsync();
var slusajuPredemt = _dbContext.SlusaPredmet.Where(x => x.AngazovanId == cas.AngazovanId);
foreach (var x in slusajuPredemt)
{
await _dbContext.AddAsync(new OdrzaniCasDetalji
{
OdrzaniCasId = cas.Id,
Prisutan = true,
SlusaPredmetId = x.Id
});
}
await _dbContext.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public async Task <IActionResult> Create([Bind("Id,Naziv,Opis,Cijena,Slika")] Hrana jela, IFormFile Slika)
{
if (ModelState.IsValid)
{
if (Slika == null)
{
ViewData["INFO"] = "Slija je null";
}
if (Slika != null)
{
if (Slika.Length > 0)
{
byte[] SlikaBitovi = null;
using (var fs1 = Slika.OpenReadStream())
using (var ms1 = new MemoryStream())
{
fs1.CopyTo(ms1);
SlikaBitovi = ms1.ToArray();
}
jela.Slika = SlikaBitovi;
}
}
_context.Add(jela);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(jela));
}
public async Task <IActionResult> UrediPrisustvo(UredjivanjePrisustvaVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Podaci nisu validni."));
}
try
{
var odrzaniCasStavka = await _context.OdrzaniCasStavke.FindAsync(model.OdrzaniCasStavkaId);
if (odrzaniCasStavka == null)
{
return(BadRequest("Prisustvo nije pronadjeno."));
}
if (model.IsPrisutan)
{
odrzaniCasStavka.Ocjena = model.Ocjena;
}
else
{
odrzaniCasStavka.OpravdanoOdsustvo = model.OpravdanoOdsutan;
odrzaniCasStavka.Napomena = model.Napomena;
}
_context.Update(odrzaniCasStavka);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
return(ViewComponent("SinglePrisustvo", new { odrzaniCasStavkaId = model.OdrzaniCasStavkaId }));
}
public async Task <IActionResult> Snimi(IspitPolaganjeVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Podaci nisu validni."));
}
if (!model.Ocjena.HasValue)
{
var ispitTerminDecryptedId = int.Parse(_protector.Unprotect(model.IspitniTerminId));
var ispitniTermin = await _context.IspitniTermini.FindAsync(ispitTerminDecryptedId);
if (ispitniTermin == null)
{
return(NotFound("Ispitni termin nije pronadjne."));
}
var novoPolaganje = new IspitPolaganje
{
IspitniTerminId = int.Parse(_protector.Unprotect(model.IspitniTerminId)),
Ocjena = 0,
PristupioIspitu = false,
UpisGodineId = int.Parse(_protector.Unprotect(model.UpisGodineId))
};
await _context.AddAsync(novoPolaganje);
await _context.SaveChangesAsync();
ViewData["evidentiraniRezultati"] = ispitniTermin.EvidentiraniRezultati;
ViewData["datumIspita"] = ispitniTermin.DatumIspita;
return(PartialView("_PolaganjeIspitaRow", await BuildPolaganjeIspitaVM(novoPolaganje)));
}
var polaganjeFromDb = await _context.PolaganjaIspita
.Include(x => x.IspitniTermin)
.FirstOrDefaultAsync(x => x.Id == int.Parse(_protector.Unprotect(model.Id)));
if (polaganjeFromDb == null)
{
return(BadRequest("Polaganje ne postoji."));
}
polaganjeFromDb.Ocjena = model.Ocjena;
polaganjeFromDb.PristupioIspitu = true;
_context.Update(polaganjeFromDb);
await _context.SaveChangesAsync();
ViewData["evidentiraniRezultati"] = polaganjeFromDb.IspitniTermin.EvidentiraniRezultati;
ViewData["datumIspita"] = polaganjeFromDb.IspitniTermin.DatumIspita;
return(PartialView("_PolaganjeIspitaRow", await BuildPolaganjeIspitaVM(polaganjeFromDb)));
}
public async Task <IActionResult> Create([Bind("Id,VaziDo,BrojKartice,CVV,TipKarticeID")] KreditneKartice kreditneKartice)
{
if (ModelState.IsValid)
{
_context.Add(kreditneKartice);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["TipKarticeID"] = new SelectList(_context.TipKartice, "Id", "Naziv", kreditneKartice.TipKarticeID);
return(View(kreditneKartice));
}
public async Task <IActionResult> Create([Bind("Id,BrojSobe,BrojSprata,Cijena,TipSobeID")] Sobe sobe)
{
if (ModelState.IsValid)
{
_context.Add(sobe);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["TipSobeID"] = new SelectList(_context.TipSobe, "Id", "Naziv", sobe.TipSobeID);
return(View(sobe));
}
public async Task <ServiceResult> DodajOdrzaniCas(OdrzaniCas cas)
{
if (await _context.OdrzaniCasovi.AnyAsync(x => x.PredajePredmetId == cas.PredajePredmetId &&
x.Datum == cas.Datum))
{
return new ServiceResult
{
Message = "Isti cas vec postoji.",
Success = false
}
}
;
try
{
await _context.AddAsync(cas);
await _context.SaveChangesAsync();
var uceniciOdjeljenje = _context.OdjeljenjeStavka.Where(x => x.OdjeljenjeId == cas.OdjeljenjeId);
if (await uceniciOdjeljenje.AnyAsync())
{
foreach (var u in uceniciOdjeljenje)
{
await _context.AddAsync(new OdrzaniCasStavka
{
IsPrisutan = false,
Napomena = string.Empty,
Ocjena = 0,
OdjeljenjeStavkaId = u.Id,
OdrzaniCasId = cas.Id,
OpravdanoOdsustvo = false
});
}
await _context.SaveChangesAsync();
}
}
catch (Exception ex)
{
return(new ServiceResult
{
Message = ex.Message,
Success = false
});
}
return(new ServiceResult
{
Message = "Uspjesno dodat cas.",
Success = true
});
}
public async Task <IActionResult> Create([Bind("Id,NamjestajID,TipSobeID")] TipSobeMoguciNamjestaj tipSobeMoguciNamjestaj)
{
if (ModelState.IsValid)
{
_context.Add(tipSobeMoguciNamjestaj);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["NamjestajID"] = new SelectList(_context.Namjestaj, "Id", "Ime", tipSobeMoguciNamjestaj.NamjestajID);
ViewData["TipSobeID"] = new SelectList(_context.TipSobe, "Id", "Naziv", tipSobeMoguciNamjestaj.TipSobeID);
return(View(tipSobeMoguciNamjestaj));
}
public async Task <ServiceResult> DodajCas(OdrzaniCas cas)
{
if (cas == null)
{
return new ServiceResult {
Message = "Morate proslijediti cas koji zelite dodati.", Success = false
}
}
;
try
{
await _context.AddAsync(cas);
await _context.SaveChangesAsync();
if (cas.Angazovan == null)
{
cas.Angazovan = await _context.Angazovani.FindAsync(cas.AngazovanId);
}
foreach (var x in _context.UpisiUOdjeljenja
.Where(x => x.OdjeljenjeId == cas.Angazovan.OdjeljenjeId))
{
await _context.AddAsync(new OdrzaniCasDetalj
{
OdrzaniCasId = cas.Id,
Odsutan = false,
UpisUOdjeljenjeId = x.Id
});
}
await _context.SaveChangesAsync();
return(new ServiceResult {
Message = "Uspjesno dodat novi odrzani cas.", Success = true
});
}
catch (Exception ex)
{
return(new ServiceResult {
Message = ex.Message, Success = false
});
}
return(new ServiceResult {
Message = "Neuspjesno dodavanje odrzanog casa.", Success = false
});
}
public async Task <ServiceResult> Dodaj(MaturskiIspit ispit)
{
if (ispit == null)
{
return new ServiceResult {
Success = false, Message = string.Empty
}
}
;
try
{
await _dbContext.AddAsync(ispit);
await _dbContext.SaveChangesAsync();
var uceniciZaDodavanje = _dbContext.UpisUOdjeljenje
.Where(x => x.OdjeljenjeId == ispit.OdjeljenjeId && x.OpciUspjeh > 1);
foreach (var x in uceniciZaDodavanje)
{
if (!await IsVecPolozio(x.Id))
{
await _dbContext.AddAsync(new MaturskiIspitStavka
{
Bodovi = null,
MaturskiIspitId = ispit.Id,
Oslobodjen = x.OpciUspjeh == 5,
UpisUOdjeljenjeId = x.Id
});
}
}
await _dbContext.SaveChangesAsync();
return(new ServiceResult
{
Success = true,
Message = "Uspjesno dodat maturski ispit."
});
}
catch (Exception ex)
{
return(new ServiceResult
{
Message = ex.Message,
Success = false
});
}
}
public async Task <IActionResult> PrisustvoToggler(int Id)
{
var prisustvo = await _context.OdrzaniCasDetalji.FindAsync(Id);
if (prisustvo == null)
{
return(NotFound("Prisustvo nije pronadjeno."));
}
prisustvo.Odsutan = !prisustvo.Odsutan;
_context.Update(prisustvo);
await _context.SaveChangesAsync();
return(ViewComponent("PrisustvoCasu", new { odrzaniCasDetaljiId = Id }));
}
public async Task <IActionResult> UcesnikJePristupio(int takmicenjeUcesnikId)
{
var takmicenjeUcesnik = await _context.TakmicenjeUcesnici.FindAsync(takmicenjeUcesnikId);
if (takmicenjeUcesnik == null)
{
return(BadRequest("Ucesnik nije pronadjen."));
}
takmicenjeUcesnik.IsPristupio = true;
_context.Update(takmicenjeUcesnik);
await _context.SaveChangesAsync();
return(ViewComponent("SingleRezultatTakmicenja", new{ takmicenjeUcesnikId = takmicenjeUcesnikId }));
}
public async Task <IActionResult> Snimi(OdrzaniCasInputVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { ModelStateErrors = ModelState.Values.SelectMany(x => x.Errors) }));
}
if (model.Id.HasValue)
{
var odrzaniCasFromDb = await _context.OdrzaniCasovi.FindAsync(model.Id.Value);
if (odrzaniCasFromDb == null)
{
return(NotFound("Odrzani cas nije pronadjen."));
}
odrzaniCasFromDb.datum = model.DatumOdrzanogCasa;
odrzaniCasFromDb.AngazovanId = model.AngazovanId;
_context.Update(odrzaniCasFromDb);
}
else
{
var noviOdrzaniCas = new OdrzaniCas
{
datum = model.DatumOdrzanogCasa,
AngazovanId = model.AngazovanId
};
var dodavanjeCasaResult = await _odrzaniCasService.DodajCas(noviOdrzaniCas);
if (!dodavanjeCasaResult.Success)
{
return(BadRequest(new
{
Error = dodavanjeCasaResult.Message,
Message = "Dodavanje casa neuspjesno."
}));
}
}
await _context.SaveChangesAsync();
return(Ok("Uspjesno evidentiran odrzani cas."));
}
public async Task <ServiceResult> ObrisiOdjeljenje(int odjeljenjeId)
{
var odjeljenje = _context.Odjeljenje.Find(odjeljenjeId);
if (odjeljenje == null)
{
return new ServiceResult {
Message = "Odjeljenje nije pronadjeno",
Failed = true
}
}
;
foreach (var dodjeljeniPredmet in _context.DodjeljenPredmet
.Where(x => x.OdjeljenjeStavka.OdjeljenjeId == odjeljenjeId))
{
_context.Remove(dodjeljeniPredmet);
}
foreach (var odjeljenjeStavka in _context.OdjeljenjeStavka
.Where(x => x.OdjeljenjeId == odjeljenjeId))
{
_context.Remove(odjeljenjeStavka);
}
_context.Remove(odjeljenje);
await _context.SaveChangesAsync();
return(new ServiceResult {
Message = "Uspjesno brisanje odjeljenja",
Success = true
});
}
public async Task <IActionResult> PonistiNarudzbu(int narudzbaID, int SobaId)
{
db.Narudzbe.Remove(db.Narudzbe.Find(narudzbaID));
await db.SaveChangesAsync();
ZaduzeneSobe soba = await db.ZaduzeneSobe.Include(x => x.Rezervacija).SingleOrDefaultAsync(x => x.Id == SobaId);
return(RedirectToAction("Info", "Rezervacije", new { id = soba.RezervacijaId }));
}
public async Task <IActionResult> EvidencijaSnimi(RezultatPretrageInputVM model)
{
int decryptedId = int.Parse(_protector.Unprotect(model.Id));
var rezultatPretrage = await _context.RezultatPretrage
.Include(x => x.LabPretraga)
.FirstOrDefaultAsync(x => x.Id == decryptedId);
if (rezultatPretrage == null)
{
return(BadRequest("Rezultat pretrage nije pronadjen."));
}
if (model.ModalitetId != null)
{
rezultatPretrage.ModalitetId = model.ModalitetId;
}
else
{
rezultatPretrage.NumerickaVrijednost = model.IzmjerenaVrijednost;
}
_context.Update(rezultatPretrage);
await _context.SaveChangesAsync();
if (model.ModalitetId != null)
{
var modalitet = await _context.FindAsync <Modalitet>(model.ModalitetId);
return(Ok(
new
{
Vrijednost = modalitet?.Opis ?? "",
IsReferentna = modalitet?.IsReferentnaVrijednost ?? false
}));
}
return(Ok(new
{
Vrijednost = rezultatPretrage.NumerickaVrijednost?.ToString() ?? "",
IsReferentna = rezultatPretrage.NumerickaVrijednost <= rezultatPretrage.LabPretraga.ReferentnaVrijednostMax &&
rezultatPretrage.NumerickaVrijednost >= rezultatPretrage.LabPretraga.ReferentnaVrijednostMin
}));
}
public async Task <IActionResult> Novi(NoviIspitniTerminVM model)
{
if (!ModelState.IsValid)
{
var datumError = ModelState.Values
.SelectMany(x => x.Errors)
.FirstOrDefault(x => x.ErrorMessage.Contains("Datum"));
if (datumError != null)
{
ModelState.AddModelError(string.Empty, datumError.ErrorMessage);
}
return(View(model));
}
int decryptedAngazmanId = int.Parse(_protector.Unprotect(model.AngazmanId));
var angazman = _context.Angazovan.Find(decryptedAngazmanId);
if (angazman == null)
{
return(BadRequest("Ne mozete dodati ispitne termine za ovaj predmet."));
}
var noviTermin = new IspitniTermin
{
AngazovanId = decryptedAngazmanId,
BrojPrijavljenihStudenata = 0,
BrojNepolozenih = 0,
DatumIspita = model.Datum,
EvidentiraniRezultati = false
};
await _context.AddAsync(noviTermin);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(GetAll), routeValues: new{ angazmanId = model.AngazmanId }));
}
public async Task <IActionResult> Uredi([FromForm] int maturskiIspitId, [FromForm] string napomena)
{
var maturskiIspit = await _context.MaturskiIspiti.FindAsync(maturskiIspitId);
if (maturskiIspit == null)
{
return(NotFound("Maturski ispit nije pronadjen."));
}
if (string.IsNullOrEmpty(napomena) || napomena.Length > 150)
{
return(BadRequest("Napomena moze sadrzati izmedju 1 i 100 karaktera"));
}
maturskiIspit.Napomena = napomena;
_context.Update(maturskiIspit);
await _context.SaveChangesAsync();
return(Ok("Uspjesno evidentirana napomena."));
}
public async Task <IActionResult> SnimiPolaganje(PopravniIspitStavkaInputVM model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Podaci nisu validni."));
}
PopravniIspitStavka stavka;
if (model.Id.HasValue)
{
stavka = await _context.PopravniIspitStavke.FindAsync(model.Id);
if (stavka == null)
{
return(BadRequest("Polaganje nije pronadjena."));
}
stavka.OsvojeniBodovi = model.Bodovi;
_context.Update(stavka);
}
else
{
stavka = new PopravniIspitStavka
{
ImaPravoNaIzlazask = true,
IsPrisutupio = false,
PopravniIspitId = model.PopravniIspitId,
OsvojeniBodovi = model.Bodovi,
UcenikId = model.UcenikId
};
await _context.AddAsync(stavka);
}
await _context.SaveChangesAsync();
return(ViewComponent("SinglePolaganjePopravnog", new { popravniIspitStavkaId = stavka.Id }));
}
public async Task <ServiceResult> DodajAsync(Uputnica uputnica)
{
try
{
if (await _context.Uputnica
.AnyAsync(x => x.PacijentId == uputnica.PacijentId &&
x.VrstaPretrageId == uputnica.VrstaPretrageId &&
x.DatumUputnice.Date == uputnica.DatumUputnice.Date))
{
return new ServiceResult {
Failed = true,
Message = "Ista uputnica vec postoji."
}
}
;
await _context.AddAsync(uputnica);
await _context.SaveChangesAsync();
await KreirajNoveRezultatePretraga(uputnica.VrstaPretrageId, uputnica.Id);
}
catch (Exception ex)
{
return(new ServiceResult
{
Failed = true,
Message = ex.Message
});
}
return(new ServiceResult
{
Message = "Uspjesno kreirana uplatnica.",
Success = true
});
}
public async Task <IActionResult> Create([Bind("Id,TipSobeID,TipNamjestaja,Kolicina")] TipSobeNamjestaj tipSobeNamjestaj)
{
if (ModelState.IsValid)
{
TipSobeNamjestaj postoji = db.TipSobeNamjestaj.SingleOrDefault(x => x.TipSobeID == tipSobeNamjestaj.TipSobeID && (int)x.TipNamjestaja == (int)tipSobeNamjestaj.TipNamjestaja);
if (postoji != null)
{
postoji.Kolicina = tipSobeNamjestaj.Kolicina;
db.TipSobeNamjestaj.Update(postoji);
await db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
db.Add(tipSobeNamjestaj);
await db.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["TipSobeID"] = new SelectList(db.TipSobe, "Id", "Naziv", tipSobeNamjestaj.TipSobeID);
return(View(tipSobeNamjestaj));
}
public async Task <IActionResult> Zakljucaj(string Id)
{
int decryptedId = int.Parse(_protector.Unprotect(Id));
var uputnica = await _context.Uputnica.FindAsync(decryptedId);
if (uputnica == null)
{
return(BadRequest("Uputnica nije pronadjena."));
}
uputnica.IsGotovNalaz = true;
uputnica.DatumRezultata = DateTime.Now;
_context.Update(uputnica);
await _context.SaveChangesAsync();
return(Ok(uputnica.DatumRezultata.Value.ToString("g")));
}
public async Task <ActionResult <Rezervacije> > SpremiRezervaciju(Rezervacije rezervacija)
{
var found = _context.rezervacije.Include(x => x.Termin).Where(x => x.UserId == rezervacija.UserId &&
rezervacija.Dan == x.Dan && rezervacija.Mjesec == x.Mjesec &&
rezervacija.Godina == x.Godina).FirstOrDefault();
if (found != null)
{
return(null);
}
else
{
var termin = _context.termini.Find(rezervacija.TerminId);
rezervacija.Termin = termin;
rezervacija.DatumRezervacije = DateTime.Now;
_context.rezervacije.Add(rezervacija);
await _context.SaveChangesAsync();
return(rezervacija);
}
}