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 <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 <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 <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 <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 <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> 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> 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> PrebaciUViseOdjeljenje(Odjeljenje novoOdjeljenje, Odjeljenje nizeOdjeljenje = null)
{
if (novoOdjeljenje == null)
{
return new ServiceResult
{
Message = "Greska",
Failed = true
}
}
;
if (_context.Odjeljenje.Any(x => x.Oznaka == novoOdjeljenje.Oznaka))
{
return new ServiceResult
{
Message = "Odjeljenje sa istom oznakom vec postoji.",
Failed = true
}
}
;
if (nizeOdjeljenje != null)
{
if (nizeOdjeljenje.Razred >= novoOdjeljenje.Razred)
{
return new ServiceResult
{
Message = "Razred u koji se prebacuje staro odjeljenje mora biti veci od trenutnog.",
Failed = true
}
}
;
if (!IsValidnaNarednaSkolskaGodina(nizeOdjeljenje.SkolskaGodina, novoOdjeljenje.SkolskaGodina))
{
return new ServiceResult
{
Message = "Skolska godina mora biti za jednu godinu veca od stare skolske godine.",
Failed = true
}
}
;
nizeOdjeljenje.IsPrebacenuViseOdjeljenje = true;
_context.Update(nizeOdjeljenje);
var stavke = new List <OdjeljenjeStavka>();
var dodjeljeniPredmetiNovi = new List <DodjeljenPredmet>();
await _context.AddAsync(novoOdjeljenje);
await _context.SaveChangesAsync();
foreach (var stavka in _context.OdjeljenjeStavka
.Where(x => x.OdjeljenjeId == nizeOdjeljenje.Id))
{
if (!_ucenikService.IsNegativanOpstiUspjeh(stavka.UcenikId, stavka.OdjeljenjeId))
{
stavke.Add(new OdjeljenjeStavka
{
BrojUDnevniku = 0,
OdjeljenjeId = novoOdjeljenje.Id,
UcenikId = stavka.UcenikId
});
await _context.AddAsync(stavke.Last());
await _context.SaveChangesAsync();
foreach (var predmet in _context.Predmet.Where(x => x.Razred == novoOdjeljenje.Razred))
{
dodjeljeniPredmetiNovi.Add(new DodjeljenPredmet
{
OdjeljenjeStavkaId = stavke.Last().Id,
PredmetId = predmet.Id,
ZakljucnoKrajGodine = 0,
ZakljucnoPolugodiste = 0
});
}
}
}
if (dodjeljeniPredmetiNovi.Any())
{
await _context.AddRangeAsync(dodjeljeniPredmetiNovi);
}
await _context.SaveChangesAsync();
}
return(new ServiceResult
{
Message = "Uspjesno kreirano novo odjeljenje.",
Success = true
});
}
public async Task <ServiceResult> DodajNovi(MaturskiIspit maturskiIspit)
{
if (maturskiIspit == null)
{
return new ServiceResult {
Message = "Maturski ispit nije validan.", Success = false
}
}
;
if (await _context.MaturskiIspiti.AnyAsync(x => x.PredmetId == maturskiIspit.PredmetId &&
x.DatumOdrzavanja.Date == maturskiIspit.DatumOdrzavanja.Date))
{
return new ServiceResult {
Message = "Maturski ispit vec postoji.", Success = false
}
}
;
try
{
await _context.AddAsync(maturskiIspit);
await _context.SaveChangesAsync();
var uceniciIspunjavajuUslov = _context.DodjeljenPredmet
.Where(x => x.OdjeljenjeStavka.Odjeljenje.SkolaID == maturskiIspit.SkolaId &&
x.OdjeljenjeStavka.Odjeljenje.SkolskaGodinaID == maturskiIspit.SkolskaGodinaId)
.Select(x => x.OdjeljenjeStavka.Ucenik)
.AsEnumerable()
.DistinctBy(x => x.Id);
foreach (var x in uceniciIspunjavajuUslov)
{
if (await IspunjavaUslovPolaganja(x.Id))
{
await _context.AddAsync(new MaturskiIspitStavka
{
IsPristupio = false,
MaturskiIspitId = maturskiIspit.Id,
OsvojeniBodovi = 0,
UcenikId = x.Id
});
}
}
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
return(new ServiceResult {
Message = ex.Message, Success = false
});
}
return(new ServiceResult {
Message = "Uspjesno dodat maturski ispit.", Success = true
});
}
public async Task <ServiceResult> DodajTakmicenje(Takmicenje takmicenje)
{
if (await _context.Takmicenja.AnyAsync(x => x.PredmetId == takmicenje.PredmetId &&
x.DatumOdrzavanja.Date == takmicenje.DatumOdrzavanja.Date))
{
return new ServiceResult
{
Message = "Takmicenje vec dodato.",
Success = false
}
}
;
try
{
await _context.AddAsync(takmicenje);
await _context.SaveChangesAsync();
var uceniciOcjenaPet = _context.DodjeljenPredmet
.Include(x => x.OdjeljenjeStavka)
.Where(x => x.PredmetId == takmicenje.PredmetId && x.ZakljucnoKrajGodine == 5);
var uceniciVeciProsjekOdCetiri = new List <DodjeljenPredmet>();
if (await uceniciOcjenaPet.AnyAsync())
{
foreach (var u in uceniciOcjenaPet)
{
if (ProsjekUcenika(u.OdjeljenjeStavka.UcenikId, takmicenje.Razred) >= 4)
{
await _context.TakmicenjeUcesnici.AddAsync(new TakmicenjeUcesnik
{
TakmicenjeId = takmicenje.Id,
OdjeljenjeStavkaId = u.OdjeljenjeStavkaId,
IsPristupio = false,
OsvojeniBodovi = 0
});
}
}
await _context.SaveChangesAsync();
}
}
catch (Exception ex)
{
return(new ServiceResult
{
Message = ex.Message,
Success = false
});
}
return(new ServiceResult
{
Message = "Uspjesno dodato novo takmicenje.",
Success = true
});
}
