public frmImport()
{
repClinic = new ClinicRepository();
repDefine = new DefineRepository();
repMedicine = new MedicineRepository();
repwh = new WareHouseRepository();
repwhDetail = new WareHouseDetailRepository();
_repwhIo = new WareHouseIORepository();
_repwhIoDetail = new WareHouseIODetailRepository();
InitializeComponent();
repClinic = new ClinicRepository();
FillToComboboxClinic(0);
dateImport.Value = DateTime.Now.Date;
try
{
InitGrid();
//bindingSource3.DataSource = repMedicine.GetAll();
}
catch (Exception ex)
{
throw;
}
}
public async Task GetPatientReportsAsync_Database_test1(int id)
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var patientReport = await repo.GetPatientReportsAsync(id);
var patientReportActual = context.PatientReports.Where(x => x.PatientId == id);
var vitalsActual = context.Vitals.Where(x => patientReportActual.Select(y => y.VitalsId).Contains(x.Id));
foreach (var report in patientReport)
{
Assert.Contains(report.Id, patientReportActual.Select(x => x.Id));
if (report.Vitals is not null)
{
Assert.Contains(report.Vitals.Id, vitalsActual.Select(x => x.Id));
Assert.Contains(report.Vitals.Systolic, vitalsActual.Select(x => x.Systolic));
Assert.Contains(report.Vitals.Diastolic, vitalsActual.Select(x => x.Diastolic));
Assert.Contains(report.Vitals.HeartRate, vitalsActual.Select(x => x.HeartRate));
Assert.Contains(report.Vitals.PainLevel, vitalsActual.Select(x => x.Pain));
}
Assert.Contains(report.Info, patientReportActual.Select(x => x.Information));
Assert.Contains(report.Time, patientReportActual.Select(x => x.ReportTime));
Assert.Contains(report.PatientId, patientReportActual.Select(x => x.PatientId));
}
}
public ClinicView PostEditMethod(ClinicView cv)
{
using (var clinicrepo = new ClinicRepository())
{
if (cv.ClinicId == 0)
{
Clinic _clinic = new Clinic
{
ClinicId = cv.ClinicId,
ClinicName = cv.ClinicName
};
clinicrepo.Insert(_clinic);
}
else
{
Clinic _clinic = clinicrepo.GetById(cv.ClinicId);
_clinic.ClinicId = cv.ClinicId;
_clinic.ClinicName = cv.ClinicName;
clinicrepo.Update(_clinic);
}
return(cv);
}
}
public async Task AddTimeslotAsync_Database_test1()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var timeslot = new Domain.Models.Timeslot(new DateTime(2020, 12, 20, 8, 0, 0))
{
Appointment = new Domain.Models.Appointment(5, "idiot can't find his stethoscope")
{
PatientId = 7,
DoctorId = 4
},
Id = 9,
DoctorId = 4
};
await repo.AddTimeslotAsync(timeslot);
var timeslotActual = context.Timeslots.Find(9);
Assert.Equal(timeslotActual.Id, timeslot.Id);
Assert.Equal(timeslotActual.DoctorId, timeslot.DoctorId);
Assert.Equal(timeslotActual.AppointmentId, timeslot.Appointment?.Id);
Assert.Equal(timeslotActual.Start, timeslot.Start);
Assert.Equal(timeslotActual.End, timeslot.End);
}
public async Task AddPatientAsync_Database_Test()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var patient = new VirtualClinic.Domain.Models.Patient("Billy Mays", DateTime.Now)
{
SSN = "293-38-0071",
InsuranceProvider = "Umbrella Corp",
PrimaryDoctor = repo.GetDoctorByID(1)
};
await repo.AddPatientAsync(patient);
using var context2 = new ClinicDbContext(options);
DataModel.Patient patientActual = context2.Patients
.Single(l => l.Name == "Billy Mays");
Assert.Equal(patient.Name, patientActual.Name);
Assert.Equal(patient.SSN, patientActual.Ssn);
Assert.Equal(patient.InsuranceProvider, patientActual.Insurance);
}
public frmExportDetail(int exportId)
{
repClinic = new ClinicRepository();
repDefine = new DefineRepository();
repMedicine = new MedicineRepository();
repwh = new WareHouseRepository();
repwhDetail = new WareHouseDetailRepository();
_repwhIo = new WareHouseIORepository();
_repwhIoDetail = new WareHouseIODetailRepository();
whExport = new WareHouseExportAllocateRepository();
InitializeComponent();
repClinic = new ClinicRepository();
cbClinic.DataSource = repClinic.GetAll();
dateImport.Value = DateTime.Now.Date;
whPaperId = exportId;
try
{
InitGrid();
LoadData(exportId);
}
catch (Exception ex)
{
throw;
}
}
public EquipmentServiceShould(DatabaseFixture fixture) : base(fixture)
{
var clinicRepository = new ClinicRepository(Context);
equipmentRepository = new EquipmentRepository(Context);
sut = new EquipmentAppService(equipmentRepository, clinicRepository);
}
public async Task AddPrescriptionAsync_Database_test()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var prescription = new Domain.Models.Prescription("Take every 3 hours", "blarbazin")
{
Id = 8,
PatientId = 1,
DoctorId = 1
};
await repo.AddPrescriptionAsync(prescription);
var prescriptionActual = context.Prescriptions.Find(8);
Assert.Equal(prescription.Id, prescriptionActual.Id);
Assert.Equal(prescription.Info, prescriptionActual.Information);
Assert.Equal(prescription.DrugName, prescriptionActual.Drug);
Assert.Equal(prescription.DoctorId, prescriptionActual.DoctorId);
Assert.Equal(prescription.PatientId, prescriptionActual.PatientId);
}
public TestShould(RealDatabaseFixture dbFixture, ITestOutputHelper testOutputHelper)
{
this.HostingEnvironment = dbFixture.HostingEnvironment;
this.Context = dbFixture.Context;
clinicRepository = new ClinicRepository(Context);
this.console = testOutputHelper;
}
public ClinicAppServiceShould(DatabaseFixture dbFixture) : base(dbFixture)
{
var configuration = new Mock <IConfiguration>();
var serviceProvider = new Mock <IServiceProvider>();
clinicRepository = new ClinicRepository(base.Context);
clinicAppService = new ClinicAppService(clinicRepository);
}
public ClinicControllerShould(DatabaseFixture dbFixture) : base(dbFixture)
{
var logger = new Mock <ILogger <ClinicController> >();
var clinicReposiyory = new ClinicRepository(Context);
var clinicAppService = new ClinicAppService(clinicReposiyory);
clinicController = new ClinicController(clinicAppService, logger.Object);
}
public List <ClinicView> GetAllClinics()
{
using (var clinicrepo = new ClinicRepository())
{
return(clinicrepo.GetAll().Select(x => new ClinicView()
{
ClinicId = x.ClinicId, ClinicName = x.ClinicName
}).ToList());
}
}
public async Task GetPatientReportsByIDAsync_Database_test2(int id)
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
await Assert.ThrowsAsync <ArgumentException>(() => repo.GetPatientReportByIDAsync(id));
}
public void PostDeleteMethod(int id)
{
using (var clinicrepo = new ClinicRepository())
{
if (id != 0)
{
Clinic _clinic = clinicrepo.GetById(id);
clinicrepo.Delete(_clinic);
}
}
}
public ClinicView GetClinicId(int?id)
{
ClinicView cv = new ClinicView();
using (var clinicrepo = new ClinicRepository())
{
Clinic _clinic = clinicrepo.GetById(id.Value);
cv.ClinicId = _clinic.ClinicId;
return(cv);
}
}
public void GetDoctorbyID_Database_test(int id)
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var doctor = repo.GetDoctorByID(id);
var doctorActual = context.Doctors.Where(x => x.Id == id).Single();
Assert.Equal(doctor.Id, doctorActual.Id);
Assert.Equal(doctor.Name, doctorActual.Name);
}
public void CreateMethod(ClinicView cv)
{
using (var clinicrepo = new ClinicRepository())
{
if (cv.ClinicId == 0)
{
Clinic _clinic = new Clinic
{
ClinicId = cv.ClinicId,
ClinicName = cv.ClinicName
};
clinicrepo.Insert(_clinic);
}
}
}
public async Task GetPatientbyIDAsync_Database_test(int id)
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var patient = await repo.GetPatientByIDAsync(id);
var patientsActual = context.Patients.Where(x => x.Id == id).Single();
Assert.Equal(patient.Id, patientsActual.Id);
Assert.Equal(patient.Name, patientsActual.Name);
Assert.Equal(patient.SSN, patientsActual.Ssn);
}
public UnitOfWork(
IDataMapper mapper,
ClinicDb context)
{
_mapper = mapper;
_context = context;
UserRepository = new UserRepository(mapper, context);
BookingRepository = new BookingRepository(mapper, context);
RefreshTokenRepository = new RefreshTokenRepository(mapper, context);
ClinicClinicianRepository = new ClinicClinicianRepository(context);
DocumentRepository = new DocumentRepository(context);
ClinicRepository = new ClinicRepository(mapper, context);
ClinicianRepository = new ClinicianRepository(mapper, context);
PatientRepository = new PatientRepository(context);
}
public ClinicView GETeditMethod(int?id)
{
ClinicView cv = new ClinicView();
using (var clinicrepo = new ClinicRepository())
{
if (id.HasValue && id != 0)
{
Clinic _clinic = clinicrepo.GetById(id.Value);
cv.ClinicId = _clinic.ClinicId;
cv.ClinicName = _clinic.ClinicName;
}
return(cv);
}
}
public ClinicView GETdeleteMethod(int id)
{
ClinicView cv = new ClinicView();
using (var clinicrepo = new ClinicRepository())
{
if (id != 0)
{
Clinic _clinic = clinicrepo.GetById(id);
cv.ClinicId = _clinic.ClinicId;
cv.ClinicName = _clinic.ClinicName;
}
return(cv);
}
}
public frmMedicinePlanList()
{
repClinic = new ClinicRepository();
repMedicinePlan = new MedicinePlanRepository();
repMedicinePlanDetail = new MedicinePlanDetailRepository();
InitializeComponent();
try
{
InitGrid();
BindData();
}
catch (Exception ex)
{
throw;
}
}
public void GetDoctors_Database_test()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var doctors = repo.GetDoctors();
var doctorsActual = context.Doctors.ToList();
foreach (var doctor in doctors)
{
Assert.Contains(doctor.Name, doctorsActual.Select(x => x.Name));
Assert.Contains(doctor.Id, doctorsActual.Select(x => x.Id));
Assert.Contains(doctor.Title, doctorsActual.Select(x => x.Title));
}
}
public async Task GetPrescriptionAsync_Database_test(int id)
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var prescription = await repo.GetPrescriptionAsync(id);
var prescriptionActual = context.Prescriptions.Find(id);
Assert.Equal(prescription.Id, prescriptionActual.Id);
Assert.Equal(prescription.Info, prescriptionActual.Information);
Assert.Equal(prescription.DrugName, prescriptionActual.Drug);
Assert.Equal(prescription.DoctorId, prescriptionActual.DoctorId);
Assert.Equal(prescription.PatientId, prescriptionActual.PatientId);
}
public async Task AddPatientReportAsync_Database_test()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var report = new Domain.Models.PatientReport(patientId: 7, info: "I have a stomach ache", time: DateTime.Now);
await repo.AddPatientReportAsync(report);
var reportActual = context.PatientReports.Find(7);
Assert.Equal(report.PatientId, reportActual.PatientId);
Assert.Equal(report.Info, reportActual.Information);
Assert.Equal(report.Time, reportActual.ReportTime);
}
public frmMedicinePlanDetail(int planId)
{
InitializeComponent();
repClinic = new ClinicRepository();
repMedicinePlan = new MedicinePlanRepository();
repMedicinePlanDetail = new MedicinePlanDetailRepository();
IsOwner = false;
this.PlanId = planId;
try
{
BindData();
}
catch (Exception ex)
{
throw;
}
}
public void AddClinic(ClinicView objClinicView, IAuthenticationManager authenticationManager)
{
using (var clinicrepo = new ClinicRepository())
{
var newuser = new Template.Data.ApplicationUser()
{
Id = objClinicView.User.UserName,
UserName = objClinicView.User.UserName,
Email = objClinicView.User.UserName,
PasswordHash = UserManager.PasswordHasher.HashPassword(objClinicView.User.Password),
SecurityStamp = Guid.NewGuid().ToString()
};
var clinic = new Clinic {
ClinicId = objClinicView.ClinicId, ClinicName = objClinicView.ClinicName, User = newuser
};
clinicrepo.Insert(clinic);
}
}
public void GetPatients_Database_test()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var patients = repo.GetPatients();
var patientsActual = context.Patients.ToList();
foreach (var patient in patients)
{
Assert.Contains(patient.Name, patientsActual.Select(x => x.Name));
Assert.Contains(patient.Id, patientsActual.Select(x => x.Id));
Assert.Contains(patient.SSN, patientsActual.Select(x => x.Ssn));
Assert.Contains(patient.InsuranceProvider, patientsActual.Select(x => x.Insurance));
Assert.Contains(patient.DateOfBirth, patientsActual.Select(x => x.Dob));
}
}
public async Task GetDoctorTimeslotsAsync_Database_test()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var timeslots = await repo.GetDoctorTimeslotsAsync(1);
var timeslotsActual = context.Timeslots
.Where(x => x.DoctorId == 1).ToList();
foreach (var timeslot in timeslots)
{
Assert.Contains(timeslot.Id, timeslotsActual.Select(x => x.Id));
Assert.Contains(timeslot.Start, timeslotsActual.Select(x => x.Start));
Assert.Contains(timeslot.End, timeslotsActual.Select(x => x.End));
}
}
public async Task AddTimeslotAppointmentAsync_Database_test1()
{
using var connection = Database_init();
var options = new DbContextOptionsBuilder <ClinicDbContext>().UseSqlite(connection).Options;
using var context = new ClinicDbContext(options);
var repo = new ClinicRepository(context, new NullLogger <ClinicRepository>());
var appointment = new Domain.Models.Appointment("")
{
DoctorId = 1,
PatientId = 3
};
await repo.AddAppointmentToTimeslotAsync(appointment, 1);
var timeslotActual = context.Timeslots.Find(1);
Assert.NotNull(timeslotActual.AppointmentId);
}
