public override async Task <ServiceResult> GetById(int id, bool EagerLoaded)
{
var user = await _authService.LoggedInUser();
if (user == null)
{
return(ServiceResult.Unauthorized());
}
if (await _authService.CurrentUserIsInRoleAsync(RoleType.RadnikPrijem) ||
await _authService.CurrentUserIsInRoleAsync(RoleType.MedicinskiTehnicar) ||
await _authService.CurrentUserIsInRoleAsync(RoleType.Doktor))
{
if (!await _dbContext.Radnici
.AnyAsync(x => x.KorisnickiNalogId == user.Id && x.LicniPodaciId == id))
{
return(ServiceResult.Forbidden("Nemate permisije za pristup licnim podacima drugih uposlenika."));
}
}
else if (await _authService.CurrentUserIsInRoleAsync(RoleType.Pacijent))
{
if (!await _dbContext.Pacijenti
.Include(x => x.ZdravstvenaKnjizica)
.AnyAsync(x => x.KorisnickiNalogId == user.Id && x.ZdravstvenaKnjizica.LicniPodaciId == id))
{
return(ServiceResult.Forbidden("Nemate permisije za pristup licnim podacima drugih pacijenata."));
}
}
return(await base.GetById(id, EagerLoaded));
}
public virtual async Task <ServiceResult> GetById(int id, bool EagerLoaded)
{
TEntity result;
if (EagerLoaded)
{
result = GetWithEagerLoad(id).FirstOrDefault();
}
else
{
result = await _dbContext.Set <TEntity>().FindAsync(id);
}
if (_authService.UserIsPacijent() && !await AuthorizePacijentForGetById(id))
{
return(ServiceResult.Forbidden());
}
if (result == null)
{
return(ServiceResult.NotFound());
}
if (EagerLoaded)
{
return(ServiceResult.OK(PrepareDataForClient <TDtoEagerLoaded>(result)));
}
return(ServiceResult.OK(PrepareDataForClient <TDto>(result)));
}
public override async Task <ServiceResult> Update(int id, ZahtevZaPregledUpsertDto dtoForUpdate)
{
if (!await _authService.CurrentUserIsInRoleAsync(RoleType.Pacijent))
{
return(ServiceResult.Forbidden("Samo pacijenti imaju pristup ovom resursu."));
}
var zahtevFromDb = await _dbContext.ZahteviZaPregled.FindAsync(id);
if (zahtevFromDb == null)
{
return(new ServiceResult());
}
if (await ValidateModel(dtoForUpdate) is { } result&& !result.Succeeded)
{
return(ServiceResult.WithStatusCode(result.StatusCode, result.Message));
}
_mapper.Map(dtoForUpdate, zahtevFromDb);
await Task.Run(() =>
{
_dbContext.ZahteviZaPregled.Update(zahtevFromDb);
});
await _dbContext.SaveChangesAsync();
return(ServiceResult.OK(_mapper.Map <ZahtevZaPregledDtoLL>(zahtevFromDb)));
}
public override async Task <ServiceResult> Insert(PregledUpsertDto dtoForCreation)
{
var doktor = await _authService.GetCurrentLoggedInDoktor();
if (doktor == null)
{
return(ServiceResult.Forbidden("Samo doktori mogu kreirati novi pregled."));
}
if (await ValidateModel(dtoForCreation) is { } result&& !result.Succeeded)
{
return(ServiceResult.WithStatusCode(result.StatusCode, result.Message));
}
if (await _dbContext.Pregledi.AnyAsync(x => x.DatumPregleda == dtoForCreation.DatumPregleda))
{
return(ServiceResult.BadRequest($"Termin {dtoForCreation.DatumPregleda:g} je već zauzet"));
}
var entity = new Pregled
{
DoktorId = doktor.Id,
PacijentId = dtoForCreation.PacijentId,
ZahtevZaPregledId = dtoForCreation.ZahtevZaPregledId,
DatumPregleda = dtoForCreation.DatumPregleda,
IsOdradjen = false
};
var zahtevFromDb = await _dbContext.ZahteviZaPregled.FindAsync(dtoForCreation.ZahtevZaPregledId);
zahtevFromDb.IsObradjen = true;
await _dbContext.AddAsync(entity);
await _dbContext.SaveChangesAsync();
var pacijent = await _dbContext.Pacijenti
.Include(x => x.ZdravstvenaKnjizica)
.ThenInclude(x => x.LicniPodaci)
.FirstOrDefaultAsync(x => x.Id == entity.PacijentId);
await AddAndTrainModel(new GodisteVrijemeIdModel
{
Godiste = (uint)pacijent.ZdravstvenaKnjizica.LicniPodaci.DatumRodjenja.Year,
VrijemeUid = GetVrijemeUid(entity.DatumPregleda.TimeOfDay.Minutes)
});
return(ServiceResult.OK(_mapper.Map <PregledDtoLL>(entity)));
}
public override async Task <ServiceResult> Delete(int id)
{
var getDoktorResult = await GetDoktor(id);
if (!getDoktorResult.Succeeded)
{
return(ServiceResult.WithStatusCode(getDoktorResult.StatusCode, getDoktorResult.Message));
}
var doktorFromDb = getDoktorResult.doktor;
if (!await _authService.CurrentUserIsInRoleAsync(RoleType.Administrator) && doktorFromDb.Radnik.KorisnickiNalogId != ((await _authService.LoggedInUser())?.Id ?? 0))
{
return(ServiceResult.Forbidden("Ne mozete vrsiti izmene na drugim profilima doktora."));
}
if (await _dbContext.Uputnice.AnyAsync(x => x.UputioDoktorId == doktorFromDb.Id || x.UpucenKodDoktoraId == doktorFromDb.Id))
{
return(ServiceResult.BadRequest("Ne mozete izbrisati profil doktora sve dok postoje uputnice koje su povezane sa ovim doktorom."));
}
if (await _dbContext.ZahteviZaPregled.AnyAsync(x => x.DoktorId == doktorFromDb.Id))
{
return(ServiceResult.BadRequest("Ne mozete izbrisati profil doktora sve dok postoje zahtevi za pregled kod ovog doktora."));
}
if (await _dbContext.Pregledi.AnyAsync(x => x.DoktorId == doktorFromDb.Id))
{
return(ServiceResult.BadRequest("Ne mozete izbrisati profil doktora sve dok postoje zakazani ili odradjeni pregledi koje je odradio ovaj doktor."));
}
if (await _dbContext.ZdravstvenaKnjizica.AnyAsync(x => x.DoktorId == doktorFromDb.Id))
{
return(ServiceResult.BadRequest("Ne mozete izbrisati profil doktora sve dok ima zdravstvenih knjizica koje su povezane sa ovim doktorom."));
}
await _radnikService.Delete(doktorFromDb.RadnikId);
await Task.Run(() =>
{
_dbContext.Remove(doktorFromDb);
});
await _dbContext.SaveChangesAsync();
return(ServiceResult.NoContent());
}
/// <summary>
/// Returns Uputnica if Doktor is authorized for it
/// </summary>
/// <returns></returns>
private async Task <ServiceResult> GetUputnicaForManipulation(int id)
{
var doktor = await _authService.GetCurrentLoggedInDoktor();
if (doktor == null)
{
return(ServiceResult.Forbidden("Samo doktori mogu vrsiti izmene pregleda."));
}
var uputnicaFromDb = await _dbContext.Uputnice.FindAsync(id);
if (uputnicaFromDb == null)
{
return(ServiceResult.NotFound($"Uputnica sa ID-em {id} nije pronadjen."));
}
if (uputnicaFromDb.UputioDoktorId != doktor.Id)
{
return(ServiceResult.Forbidden("Nemate permisije za izmenu uputnica koje je kreirao drugi doktor."));
}
return(ServiceResult.OK(uputnicaFromDb));
}
public override async Task <ServiceResult> Update(int id, DoktorUpsertDto dtoForUpdate)
{
var getDoktorResult = await GetDoktor(id);
if (!getDoktorResult.Succeeded)
{
return(ServiceResult.WithStatusCode(getDoktorResult.StatusCode, getDoktorResult.Message));
}
var doktorFromDb = getDoktorResult.doktor;
if (!await _authService.CurrentUserIsInRoleAsync(RoleType.Administrator) && doktorFromDb.Radnik.KorisnickiNalogId != ((await _authService.LoggedInUser())?.Id ?? 0))
{
return(ServiceResult.Forbidden("Ne mozete vrsiti izmene na drugim profilima doktora."));
}
if (doktorFromDb.NaucnaOblastId != dtoForUpdate.NaucnaOblastId)
{
if (!await _dbContext.NaucneOblasti.AnyAsync(x => x.Id == dtoForUpdate.NaucnaOblastId))
{
return(ServiceResult.NotFound(
$"Naucna oblast sa ID-em {dtoForUpdate.NaucnaOblastId} nije pronadjena."));
}
doktorFromDb.NaucnaOblastId = dtoForUpdate.NaucnaOblastId;
await _dbContext.SaveChangesAsync();
}
_mapper.Map(dtoForUpdate, doktorFromDb.Radnik);
var radnikUpdateResult = await _radnikService.Update(doktorFromDb.RadnikId, dtoForUpdate);
if (!radnikUpdateResult.Succeeded)
{
return(ServiceResult.WithStatusCode(radnikUpdateResult.StatusCode, radnikUpdateResult.Message));
}
return(ServiceResult.OK(_mapper.Map <DoktorDtoLL>(doktorFromDb)));
}
public override async Task <ServiceResult> Insert(ZahtevZaPregledUpsertDto dtoForCreation)
{
var user = await _authService.LoggedInUser();
if (user == null)
{
return(ServiceResult.Unauthorized());
}
var pacijent = await _dbContext.Pacijenti.FirstOrDefaultAsync(x => x.KorisnickiNalogId == user.Id);
if (pacijent == null)
{
return(ServiceResult.Forbidden("Samo pacijenti mogu kreirati zahtev za pregled."));
}
if (await ValidateModel(dtoForCreation) is { } result&& !result.Succeeded)
{
return(ServiceResult.WithStatusCode(result.StatusCode, result.Message));
}
var entity = new ZahtevZaPregled
{
DoktorId = dtoForCreation.DoktorId,
PacijentId = pacijent.Id,
UputnicaId = dtoForCreation.UputnicaId,
Napomena = dtoForCreation.Napomena,
DatumVreme = DateTime.Now
};
await _dbContext.AddAsync(entity);
await _dbContext.SaveChangesAsync();
return(ServiceResult.OK(_mapper.Map <ZahtevZaPregledDtoLL>(entity)));
}
public override async Task <ServiceResult> Insert(UputnicaUpsertDto dtoForCreation)
{
var doktor = await _authService.GetCurrentLoggedInDoktor();
if (doktor == null)
{
return(ServiceResult.Forbidden());
}
if (await ValidateModel(dtoForCreation) is { } validationResult&& !validationResult.Succeeded)
{
return(ServiceResult.WithStatusCode(validationResult.StatusCode, validationResult.Message));
}
var uputnica = _mapper.Map <Uputnica>(dtoForCreation);
uputnica.UputioDoktorId = doktor.Id;
await _dbContext.AddAsync(uputnica);
await _dbContext.SaveChangesAsync();
return(ServiceResult.OK(_mapper.Map <UputnicaDtoLL>(uputnica)));
}
