protected void Page_Load(object sender, EventArgs e)
{
if (Page.IsPostBack == false)
{
examenData = new ExamenData(chain);
pacienteData = new PacienteData(chain);
hospitalData = new HospitalData(chain);
LinkedList <PACIENTE> listaPacientes = pacienteData.GetPacientes();
ddlPaciente.DataSource = listaPacientes;
ddlPaciente.DataTextField = "NombreApe";
ddlPaciente.DataValueField = "NumeroP";
ddlPaciente.DataBind();
LinkedList <Examen> listaExamenes = examenData.GetExamenPorPaciente(Int32.Parse(ddlPaciente.SelectedItem.Value));
ddlExamen.DataSource = listaExamenes;
ddlExamen.DataTextField = "Tipo";
ddlExamen.DataValueField = "IdExamen";
ddlExamen.DataBind();
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (Page.IsPostBack == false)
{
examenData = new ExamenData(chain);
pacienteData = new PacienteData(chain);
hospitalData = new HospitalData(chain);
LinkedList <Examen> listaExamenes = examenData.GetExamenes();
LinkedList <PACIENTE> listaPacientes = pacienteData.GetPacientes();
LinkedList <Hospital> listaHospitales = hospitalData.GetHospitales();
foreach (Examen examenActual in listaExamenes)
{
lbExamenesAgregar.Items.Add(new ListItem(examenActual.Tipo, examenActual.IdExamen.ToString()));
}
ddlPacientes.DataSource = listaPacientes;
ddlPacientes.DataTextField = "NombreApe";
ddlPacientes.DataValueField = "NumeroP";
ddlPacientes.DataBind();
ddlHospitales.DataSource = listaHospitales;
ddlHospitales.DataTextField = "Nombre";
ddlHospitales.DataValueField = "Nombre";
ddlHospitales.DataBind();
}
}
public HospitalData GetHospitals()
{
string NATIONAL_PARK_API_PATH = BASE_URL;
string json = "";
string finalJson = "";
HospitalData result = null;
httpClient.BaseAddress = new Uri(NATIONAL_PARK_API_PATH);
try
{
HttpResponseMessage response = httpClient.GetAsync(NATIONAL_PARK_API_PATH).GetAwaiter().GetResult();
if (response.IsSuccessStatusCode)
{
json = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
}
if (!json.Equals(""))
{
// Construct proper json, because original json that is returned from the url is an array
finalJson = "{\"data\":" + json + "}";
result = JsonConvert.DeserializeObject <HospitalData>(finalJson);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(result);
}
public async Task CreateHospitalProfileAsync(HospitalProfileInputModel input, string userId)
{
var user = this.usersRepository.All()
.Where(u => u.Id == userId)
.FirstOrDefault();
if (user == null)
{
throw new ArgumentException(GlobalConstants.NoUserRegistrationErrorMessage);
}
var hospitalData = new HospitalData
{
ApplicationUserId = userId,
Name = input.Name,
Contact = new Contact
{
Phone = input.Phone,
Email = input.Email,
},
Location = new Location
{
Country = input.Country,
City = input.City,
AdressDescription = input.AdressDescription,
},
};
await this.hospitalsRepository.AddAsync(hospitalData);
await this.hospitalsRepository.SaveChangesAsync();
var appUserHospitalData = new ApplicationUserHospitalData
{
ApplicationUserId = userId,
HospitalDataId = hospitalData.Id,
};
await this.appUsersHospitalRepository.AddAsync(appUserHospitalData);
await this.appUsersHospitalRepository.SaveChangesAsync();
var bloodBank = new BloodBank
{
HospitalDataId = hospitalData.Id,
};
await this.bloodBankRepository.AddAsync(bloodBank);
await this.bloodBankRepository.SaveChangesAsync();
var bag = new BloodBag
{
BloodBankId = bloodBank.Id,
};
await this.bagRepository.AddAsync(bag);
await this.bagRepository.SaveChangesAsync();
}
public async Task CreateRequestShouldReturnNotNullTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var hospitalDataRequestRepository = new EfDeletableEntityRepository <HospitalDataRequest>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var locationRepository = new EfDeletableEntityRepository <Location>(dbContext);
var service = new RequestsService(
requestRepository,
hospitalDataRequestRepository,
hospitalDataRepository,
recipientReques,
locationRepository);
// Seeding user
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
};
dbContext.Users.Add(user);
// Seeding hospital
var hospital = new HospitalData
{
ApplicationUserId = user.Id,
Name = "HospitalName",
Contact = new Contact
{
Phone = "123456789",
Email = "*****@*****.**",
},
Location = new Location
{
Country = "Bulgaria",
City = "Sofia",
AdressDescription = "Sofia",
},
};
dbContext.HospitalData.Add(hospital);
await dbContext.SaveChangesAsync();
await service.CreateRequestAsync(hospital.ApplicationUserId, "...", DateTime.UtcNow, EmergencyStatus.WithinDay, BloodGroup.A, RhesusFactor.Negative, 500);
var result = requestRepository
.All()
.Where(r => r.NeededQuantity == 500)
.FirstOrDefault();
Assert.NotNull(result);
}
private static async Task SeedDataAsync(ApplicationDbContext dbContext)
{
// Seeding user
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
};
dbContext.Users.Add(user);
// Seeding hospital
var hospital = new HospitalData
{
ApplicationUserId = user.Id,
Name = "HospitalName",
Contact = new Contact
{
Phone = "123456789",
Email = "*****@*****.**",
},
Location = new Location
{
Country = "Bulgaria",
City = "Sofia",
AdressDescription = "Sofia",
},
};
dbContext.HospitalData.Add(hospital);
// Seeding recipient
var recipient = new Recipient
{
HospitalDataId = hospital.Id,
FirstName = "recipient1",
MiddleName = "recipient1",
LastName = "recipient1",
Age = 85,
NeededQuantity = 500,
RecipientEmergency = EmergencyStatus.WithinWeek,
BloodGroup = BloodGroup.A,
RhesusFactor = RhesusFactor.Negative,
};
dbContext.Recipients.Add(recipient);
// Seeding recipientHospital
dbContext.RecipientHospitalData.Add(new RecipientHospitalData
{
HospitalDataId = hospital.Id,
RecipientId = recipient.Id,
});
await dbContext.SaveChangesAsync();
}
public HospitalDialog(Pharmacy pharmacy, HospitalData hospitalData = null)
{
if (pharmacy == null)
{
throw new ArgumentNullException(nameof(pharmacy));
}
Pharmacy = pharmacy;
HospitalData = hospitalData;
//Api = new SuggestClient(Secret.DadataApiToken, Secret.DadataApiURL);
}
private static async Task SeedDataAsync(ApplicationDbContext dbContext)
{
// Seeding user
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
};
dbContext.Users.Add(user);
// Seeding hospital
var hospital = new HospitalData
{
ApplicationUserId = user.Id,
Name = "HospitalName",
Contact = new Contact
{
Phone = "123456789",
Email = "*****@*****.**",
},
Location = new Location
{
Country = "Bulgaria",
City = "Sofia",
AdressDescription = "Sofia",
},
};
dbContext.HospitalData.Add(hospital);
// Seeding request
var request = new Request
{
HospitalName = hospital.Name,
Content = "",
PublishedOn = DateTime.UtcNow,
EmergencyStatus = EmergencyStatus.WithinWeek,
BloodGroup = BloodGroup.A,
RhesusFactor = RhesusFactor.Negative,
NeededQuantity = 500,
};
dbContext.Requests.Add(request);
// Seeding recipientHospital
dbContext.HospitalDonationRequests.Add(new HospitalDataRequest
{
HospitalDataId = hospital.Id,
RequestId = request.Id,
});
await dbContext.SaveChangesAsync();
}
public async Task CreateRecipientShouldThrowExceptionIfInvalidDataIsPassTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var recipientRepository = new EfDeletableEntityRepository <Recipient>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var recipientReques = new EfDeletableEntityRepository <RecipientRequest>(dbContext);
var recipientHospitalDataRepository = new EfDeletableEntityRepository <RecipientHospitalData>(dbContext);
var service = new RecipientsService(
recipientRepository,
hospitalDataRepository,
recipientReques,
recipientHospitalDataRepository);
// Seeding user
var user = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
};
dbContext.Users.Add(user);
// Seeding hospital
var hospital = new HospitalData
{
ApplicationUserId = user.Id,
Name = "HospitalName",
Contact = new Contact
{
Phone = "123456789",
Email = "*****@*****.**",
},
Location = new Location
{
Country = "Bulgaria",
City = "Sofia",
AdressDescription = "Sofia",
},
};
dbContext.HospitalData.Add(hospital);
await dbContext.SaveChangesAsync();
var result = recipientRepository
.All()
.Where(u => u.Age == 85)
.FirstOrDefault();
await Assert.ThrowsAsync <ArgumentException>(() => service.AddRecipientAsync(hospital.ApplicationUserId, "recipient1", "recipient1", "recipient1", 85, 0, EmergencyStatus.WithinWeek, BloodGroup.A, RhesusFactor.Negative));
}
public IActionResult DataView()
{
APIHandler webHandler = new APIHandler();
HospitalData result = webHandler.GetHospitals();
foreach (var item in result.data)
{
dbContext.Hospitals.Add(item);
}
dbContext.SaveChanges();
return(View(result));
}
public static HospitalData GenerateHospitalDataModel(int?id)
{
if (id == null)
{
return(null);
}
int hospitalId = id.GetValueOrDefault();
DatabaseQueryHandler dbQueryFetcher = DatabaseQueryHandler.Instance;
HospitalData hospitalData = new HospitalData(hospitalId);
hospitalData.hospitalInfo = dbQueryFetcher.GetHospitalDetail(hospitalId);
hospitalData.reviewEntryList = dbQueryFetcher.GetAllReviewEntriesByHospitalId(hospitalId).ToList();
return(hospitalData);
}
private async Task GetHospitalSettingsAsync()
{
try
{
var response =
await _core.HttpClient.GetObjectAsync <HospitalData>("hospitalinfo/get_hospitalinfo/");
Frames.Clear();
if (response.Success)
{
_settings = response.Result;
if (!string.IsNullOrEmpty(_settings.FrontImgThumbnail?.Image) /*&& _tile == null*/)
{
_tile = new TileLogoViewModel(_settings.FrontImgThumbnail?.Image);
Frames.Add(new LiveTileFrame(_tile, 8000));
}
}
}
catch { }
}
public void PopulateHospitalData(List <HospitalData> data)
{
if (data.Count > 0)
{
foreach (var hospital in data)
{
var newHospitalData = new HospitalData
{
CreatedAt = hospital.CreatedAt,
CumulativeForeign = hospital.CumulativeForeign,
CumulativeLocal = hospital.CumulativeLocal,
CumulativeTotal = hospital.CumulativeTotal,
HospitalId = hospital.HospitalId,
TreatmentForeign = hospital.TreatmentForeign,
TreatmentLocal = hospital.TreatmentLocal,
TreatmentTotal = hospital.TreatmentTotal
};
_context.HospitalStats.Add(newHospitalData);
_context.SaveChanges();
}
}
}
public async void Call()
{
if (_core.TryGetUiManager(out IUiManager ui))
{
await ui.DoWhileBusy(async() =>
{
try
{
if (_settings == null)
{
await GetHospitalSettingsAsync();
}
await GetCategoriesAsync();
await GetPrimaryColorFromImageAsync();
ui.Navigate(new HospitalInformationListViewModel(_core, _settings, _categories, _color));
}
catch (Exception ex)
{
_settings = null;
}
});
}
}
public async Task <ViewResult> DataLoad()
{
APIHandler webHandler = new APIHandler();
HospitalData result = webHandler.GetHospitals();
foreach (var item in result.data)
{
if (dbContext.Hospitals.Count() == 0)
{
dbContext.Hospitals.Add(item);
}
}
foreach (var item in dbContext.Hospitals)
{
Provider provider = new Provider();
Location location = new Location();
provider.provider_id = item.provider_id;
provider.provider_name = item.provider_name;
provider.provider_street_address = item.provider_street_address;
provider.provider_zip_code = item.provider_zip_code;
provider.total_discharges = item.total_discharges;
provider.drg_definition = item.drg_definition;
provider.average_covered_charges = item.average_covered_charges;
provider.average_medicare_payments = item.average_medicare_payments;
provider.average_medicare_payments_2 = item.average_medicare_payments_2;
location.provider_city = item.provider_city;
location.provider_state = item.provider_state;
location.hospital_referral_region_description = item.hospital_referral_region_description;
dbContext.Locations.Add(location);
provider.Location = location;
dbContext.Providers.Add(provider);
}
await dbContext.SaveChangesAsync();
return(View("Index", result));
}
public static List <HospitalData> GetFilteredData(DateTime StartDate, DateTime EndDate)
{
return(HospitalData.GetHospitalData().Where(data => (data.StartTime >= StartDate && data.EndTime <= EndDate)).ToList());
}
public async Task CreateDonationCorectlyTest()
{
var dbContext = ApplicationDbContextInMemoryFactory.InitializeContext();
var donationEventRepository = new EfDeletableEntityRepository <DonationEvent>(dbContext);
var bloodBankRepository = new EfDeletableEntityRepository <BloodBank>(dbContext);
var bagRepository = new EfDeletableEntityRepository <BloodBag>(dbContext);
var hospitalDataRepository = new EfDeletableEntityRepository <HospitalData>(dbContext);
var donorDataRepository = new EfDeletableEntityRepository <DonorData>(dbContext);
var requestRepository = new EfDeletableEntityRepository <Request>(dbContext);
var usersRepository = new EfDeletableEntityRepository <ApplicationUser>(dbContext);
var rolesRepository = new EfDeletableEntityRepository <ApplicationRole>(dbContext);
var service = new DonationEventsService(
donationEventRepository,
bloodBankRepository,
bagRepository,
hospitalDataRepository,
donorDataRepository,
requestRepository);
var userDonor = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
};
await dbContext.Users.AddAsync(userDonor);
var donor = new DonorData
{
ApplicationUserId = userDonor.Id,
};
await dbContext.DonorData.AddAsync(donor);
var userHospital = new ApplicationUser
{
UserName = "******",
Email = "*****@*****.**",
};
await dbContext.Users.AddAsync(userDonor);
var hospital = new HospitalData
{
ApplicationUserId = userHospital.Id,
};
await dbContext.HospitalData.AddAsync(hospital);
var bloodBank = new BloodBank
{
HospitalDataId = hospital.Id,
};
await dbContext.BloodBanks.AddAsync(bloodBank);
hospital.BloodBank = bloodBank;
await dbContext.SaveChangesAsync();
await service.CreateDonation(hospital.Id, donor.ApplicationUserId, 500, 0, BloodGroup.A, RhesusFactor.Negative);
var donotionEvent = donationEventRepository.All().FirstOrDefault(de => de.UserDonorId == donor.ApplicationUserId);
Assert.NotNull(donotionEvent);
}
public async Task SeedAsync(ApplicationDbContext dbContext, IServiceProvider serviceProvider)
{
var userManager = serviceProvider.GetRequiredService <UserManager <ApplicationUser> >();
var hospitalDataRepository = serviceProvider.GetRequiredService <IDeletableEntityRepository <HospitalData> >();
var recipientsRepository = serviceProvider.GetRequiredService <IDeletableEntityRepository <Recipient> >();
var recipientsHospitalDataRepository = serviceProvider.GetRequiredService <IDeletableEntityRepository <RecipientHospitalData> >();
var bloodBankRepository = serviceProvider.GetRequiredService <IDeletableEntityRepository <BloodBank> >();
var hospitalBloodBankRepository = serviceProvider.GetRequiredService <IDeletableEntityRepository <HospitalDataBloodBank> >();
var allUsers = serviceProvider.GetService <IDeletableEntityRepository <ApplicationUser> >();
var deletedUsers = allUsers
.AllAsNoTrackingWithDeleted()
.Where(u => u.IsDeleted == true)
.ToList();
// Seeding hospitals and hospitalsData
for (int i = 0; i < 6; i++)
{
var user = await userManager.FindByEmailAsync($"Hospital{i}@hospital.bg");
if (user != null)
{
return;
}
user = new ApplicationUser
{
UserName = $"Hospital{i}@hospital.bg",
Email = $"Hospital{i}@hospital.bg",
EmailConfirmed = true,
};
if (deletedUsers.Any(u => u.Email == user.Email))
{
return;
}
await userManager.CreateAsync(user, $"Hospital{i}@hospital.bg");
await userManager.AddToRoleAsync(user, GlobalConstants.HospitaltRoleName);
var hospitalData = new HospitalData
{
ApplicationUserId = user.Id,
ApplicationUser = user,
Name = $"Hospital{i}",
Contact = new Contact
{
Email = user.Email,
Phone = $"0{i * 5}{i * 6}{i * 7}",
},
Location = new Location
{
Country = "Bulgaria",
City = $"City{i}",
AdressDescription = $"Street{i * 3}",
},
};
await hospitalDataRepository.AddAsync(hospitalData);
var bloodBank = new BloodBank
{
HospitalDataId = hospitalData.Id,
};
await bloodBankRepository.AddAsync(bloodBank);
var hospitalBloodBank = new HospitalDataBloodBank
{
HospitalId = hospitalData.Id,
BloodBankId = bloodBank.Id,
};
await hospitalBloodBankRepository.AddAsync(hospitalBloodBank);
// Seeding recipients in hospitals
for (int j = 0; j < 3; j++)
{
Random random = new Random();
var recipient = new Recipient
{
HospitalDataId = hospitalData.Id,
FirstName = $"Recipient{j}",
MiddleName = $"Recipient{j}",
LastName = $"Recipient{j}",
Age = 20 + j,
NeededQuantity = 500,
RecipientEmergency = (EmergencyStatus)random.Next(Enum.GetNames(typeof(EmergencyStatus)).Length),
BloodGroup = (BloodGroup)random.Next(Enum.GetNames(typeof(BloodGroup)).Length),
RhesusFactor = (RhesusFactor)random.Next(Enum.GetNames(typeof(RhesusFactor)).Length),
};
await recipientsRepository.AddAsync(recipient);
var recipientHospitalData = new RecipientHospitalData
{
HospitalDataId = hospitalData.Id,
RecipientId = recipient.Id,
};
await recipientsHospitalDataRepository.AddAsync(recipientHospitalData);
}
}
}
