//TODO improve performance public List <Patient> PatientsWithSimilarDisease(int patientId) { ExceptionThrowers.ThrowErrorIfEntityNotExist(_entityTypePatient, _context, patientId); var patientRecord = _context.Records.Where(p => p.PatientId == patientId).ToList(); var patientsWithSimilarDiseasesList = new List <Patient>() { }; if (patientRecord.Count > 0) { var DbF = Microsoft.EntityFrameworkCore.EF.Functions; foreach (var item in patientRecord) { var patientIds = _context.Records.AsEnumerable <Record>() .Where(rec => rec.DiseaseName.Contains(item.DiseaseName, StringComparison.CurrentCultureIgnoreCase) && rec.PatientId != patientId) .Select(r => r.PatientId).ToArray(); var patientsWithThisDieseas = _context.Patients.AsEnumerable().Where(t => patientIds.Contains(t.Id)).ToList(); patientsWithSimilarDiseasesList.AddRange(patientsWithThisDieseas); } } return(patientsWithSimilarDiseasesList.Distinct().ToList()); }
public async Task <PatientDoctor> AddPatientDoctor(int doctorId, int patientId) { ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.doctor, _context, doctorId); ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.patinet, _context, patientId); if (await GetPatientDoctor(doctorId, patientId) != null) { throw new BadRequestException("This doctor is already assigned for this patient"); } var doctor = await _doctorRepo.GetDoctor(doctorId); var patient = await _patientRepo.GetPatient(patientId); var patientDoctor = new PatientDoctor() { DoctorId = doctorId, PatientId = patientId, Doctor = doctor, Patient = patient }; var newPatientDoctor = await _context.PatientDoctors.AddAsync(patientDoctor); await _context.SaveChangesAsync(); return(newPatientDoctor.Entity); }
public async Task <Doctor> EditDoctor(Doctor doctor) { if (doctor.OfficialId == null) { throw new InternalServerException("OfficialId is null"); } var doctorToBeUpdated = await GetDoctor(doctor.Id); ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.doctor, _context, doctor.Id); _context.Entry(doctorToBeUpdated).CurrentValues.SetValues(doctor); try { await _context.SaveChangesAsync(); return(doctor); } catch (System.Exception) { throw new Exception("Could not save"); } }
public async Task <Doctor> AddDoctor(Doctor doctor) { ExceptionThrowers.ThrowErrorIfEntiryExist(_entityTypeDoctor, _context, doctor.OfficialId); var newDoctor = await _context.Doctors.AddAsync(doctor); await _context.SaveChangesAsync(); return(newDoctor.Entity); }
public async Task <Patient> DeletePatient(Patient patient) { ExceptionThrowers.ThrowErrorIfEntityNotExist(_entityTypePatient, _context, patient.Id); patient.Archived = true; patient.ArchivedDate = DateTime.Now; await _context.SaveChangesAsync(); return(patient); }
public async Task <Doctor> DeleteDoctor(int id) { ExceptionThrowers.ThrowErrorIfEntityNotExist(_entityTypeDoctor, _context, id); var doctor = await GetDoctor(id); doctor.Archived = true; doctor.ArchivedDate = DateTime.Now; await _context.SaveChangesAsync(); return(doctor); }
public async Task <PagedList <PatientsForListDto> > GetUnAssignedPatientsToDoctor(int doctorId, PaginationParams paginationParams) { ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.doctor, _context, doctorId); var unAssignedPatients = _context.Patients.Where(P => !P.PatientDoctors.Any(pd => pd.DoctorId == doctorId && pd.Archived == false)); var pagedList = await PagedList <Patient?> .CreatePagedAsync(unAssignedPatients, paginationParams.PageNumber, paginationParams.PageSize); var pagedPatientsList = PagedListConverter <Patient?, PatientsForListDto> .Convert(pagedList, in _mapper); return(pagedPatientsList); }
public async Task <List <PatientDoctor> > GetAssignedDoctorsToPatientId(int patientId, bool?withPatientRecords) { ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.patinet, _context, patientId); var patientsForThisDoctor = _context.PatientDoctors.Where(d => d.PatientId == patientId) .Include(d => d.Doctor) .Include(p => p.Patient); if (withPatientRecords == true) { patientsForThisDoctor.Include(p => p.Patient.Records); } return(await patientsForThisDoctor.ToListAsync()); }
public Patient AddPatient(Patient patient) { ExceptionThrowers.ThrowErrorIfEntiryExist(_entityTypePatient, _context, patient.OfficialId); patient.Created = DateTime.Now; // TODO Test this patient.Records = new Collection <Record>() { }; var patientToBeCreated = _context.Patients.Add(patient).Entity; _context.SaveChanges(); return(patientToBeCreated); }
public async Task <Doctor> GetDoctor(int id) { ExceptionThrowers.ThrowErrorIfNotValidId(id); var doctor = await _context.Doctors.Include(d => d.PatientDoctors) .ThenInclude(d => d.Patient) .FirstOrDefaultAsync(d => d.Id == id); if (doctor == null) { throw new NotFoundException("Doctor not found"); } return(doctor); }
public async Task <PagedList <PatientWithAssignedDoctorsDto> > GetAssignedPatientsToDoctorId(int doctorId, PaginationParams paginationParams) { ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.doctor, _context, doctorId); var patientsForThisDoctor = _context.PatientDoctors .Where(d => d.DoctorId == doctorId && d.Archived == false) .Select(d => d.Patient) .IncludeFilter(x => x.PatientDoctors.Where(pd => pd.Archived == false)) .Include(i => i.Records); var pagedList = await PagedList <Patient> .CreatePagedAsync(patientsForThisDoctor, paginationParams.PageNumber, paginationParams.PageSize); var pagedPatientsList = PagedListConverter <Patient, PatientWithAssignedDoctorsDto> .Convert(pagedList, in _mapper); return(pagedPatientsList); }
public async Task <PatientDoctor> GetPatientDoctor(int doctorId, int patientId, bool?withPatientRecords = false) { ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.doctor, _context, doctorId); ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.patinet, _context, patientId); var patientDoctor = _context.PatientDoctors .Where(p => p.PatientId == patientId && p.DoctorId == doctorId && p.Archived == false) .Include(p => p.Patient); if (withPatientRecords == true) { patientDoctor.Include(p => p.Patient.Records); } return(await patientDoctor.FirstOrDefaultAsync()); }
public async Task <Patient> EditPatient(Patient patient) { if (patient.OfficialId == null) { throw new InternalServerException("OfficialId is null"); } ExceptionThrowers.ThrowErrorIfEntityNotExist(_entityTypePatient, _context, patient.Id); var patientToBeUpdated = await _context.Patients.FirstOrDefaultAsync(p => p.Id == patient.Id); _context.Attach(patientToBeUpdated).CurrentValues.SetValues(patient); await _context.SaveChangesAsync(); return(patient); }
public async Task <Patient> GetPatient(int id, bool?withRecords = false) { ExceptionThrowers.ThrowErrorIfNotValidId(id); Patient patient; if (withRecords == true) { patient = await _context.Patients.Include(p => p.Records).FirstOrDefaultAsync(p => p.Id == id); } else { patient = await _context.Patients.FindAsync(id); } if (patient == null) { throw new BadRequestException("Patient not found"); } return(patient); }
public async Task <PatientDoctor> RemovePatientDoctor(int doctorId, int patientId) { ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.doctor, _context, doctorId); ExceptionThrowers.ThrowErrorIfEntityNotExist(EntityType.patinet, _context, patientId); var patientDoctor = await GetPatientDoctor(doctorId, patientId, false); if (patientDoctor == null || patientDoctor.Archived == true) { throw new BadRequestException("There is no assigned relatoinship"); } patientDoctor.Archived = true; patientDoctor.ArchivedDate = DateTime.Now; await _context.SaveChangesAsync(); return(patientDoctor); }