public async Task <IHttpActionResult> PostMedication(MedicationBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var medication = new Medication()
{
MedicationId = Guid.NewGuid(),
GenericName = model.GenericName,
Code = model.Code
};
try
{
if (MedicationExists(medication) == false)
{
db.Medication.Add(medication);
await db.SaveChangesAsync();
}
else
{
return(BadRequest("The medication name or code already exists in the databae."));
}
}
catch (DbUpdateException)
{
throw;
}
return(Created("medications/" + medication.MedicationId, ToDto.MedicationToDto(medication)));
}
public async Task <IHttpActionResult> GetAssignedPatients(string providerId)
{
var user = await _userManager.FindByIdAsync(providerId);
if (user == null)
{
return(NotFound());
}
List <ApplicationUser> patients = new List <ApplicationUser>();
foreach (var careTeam in user.ProviderCareTeams)
{
if (careTeam.Active)
{
patients.Add(careTeam.Patient);
}
}
if (patients == null)
{
return(NotFound());
}
var usersDto = new List <UserDto>();
foreach (var patient in patients)
{
usersDto.Add(ToDto.UserToDto(patient));
}
return(Ok(usersDto));
}
private async Task <IHttpActionResult> GetUsersByRoleIds(string email, List <string> roleIdStrList)
{
if (email == null)
{
return(BadRequest());
}
var proxyCreation = _db.Configuration.ProxyCreationEnabled;
_db.Configuration.ProxyCreationEnabled = false;
List <ApplicationUser> providers;
providers = await _db.Users
.Where(u => u.Roles.Any(r => roleIdStrList.Any(rid => rid == r.RoleId)))
.Include(u => u.Roles)
.ToListAsync();
_db.Configuration.ProxyCreationEnabled = proxyCreation;
providers = providers.Distinct().ToList();
foreach (var provider in providers)
{
if (email == provider.Email)
{
return(Ok(ToDto.UserToDto(provider)));
}
}
return(NotFound());
}
public async Task <IHttpActionResult> PostPrescription(PrescribeBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var patient = await userManager.FindByIdAsync(model.PatientId);
if (patient == null)
{
return(NotFound());
}
var medication = await db.Medication.FindAsync(new Guid(model.MedicationId));
if (medication == null)
{
return(NotFound());
}
var prescription = new Prescription()
{
PrescriptionId = Guid.NewGuid(),
Medication = medication,
Dosage = model.Dosage,
Frequency = model.Frequency,
StartDate = model.StartDate,
EndDate = model.EndDate,
Notes = model.Notes,
Patient = patient
};
db.Prescription.Add(prescription);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (PrescriptionExists(prescription.PrescriptionId))
{
return(Conflict());
}
else
{
throw;
}
}
return(Created("prescriptions/" + prescription.PrescriptionId, ToDto.PrescriptionToDto(prescription)));
}
public async Task <IHttpActionResult> GetCareTeam(Guid id)
{
CareTeam careTeam = await db.CareTeam.FindAsync(id);
if (careTeam == null)
{
return(NotFound());
}
var roles = await db.Roles.ToDictionaryAsync(r => r.Id);
return(Ok(ToDto.CareTeamToDto(careTeam, roles)));
}
public async Task <IHttpActionResult> GetUser(string id)
{
var user = await _db.Users.Where(u => u.Id.Equals(id, StringComparison.InvariantCultureIgnoreCase))
.Include(u => u.Roles)
.FirstOrDefaultAsync();
if (user == null)
{
return(NotFound());
}
return(Ok(ToDto.UserToDto(user)));
}
public async Task <IHttpActionResult> PostUser(CreateUserBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var password = Randomizer.GetRandomString(10);
var user = new ApplicationUser()
{
UserName = model.FirstName + model.LastName + Randomizer.GetRandom(100000),
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Gender = model.Gender,
DOB = model.DOB,
PhoneNumber = model.PhoneNumber,
Specialty = model.Specialty
};
var identityResult = await _userManager.CreateAsync(user, password);
if (!identityResult.Succeeded)
{
return(BuildErrorResult(identityResult));
}
Crypteron.CipherDb.Session.Unseal(user, _db);
identityResult = await _userManager.AddToRolesAsync(user.Id, model.Roles.ToArray());
Crypteron.CipherDb.Session.Unseal(user, _db);
if (!identityResult.Succeeded)
{
return(BuildErrorResult(identityResult));
}
// Send an invitation to login and change password
MailSender sender = new MailSender();
string mailBody = "Dear " + user.FirstName + " " + user.LastName + ", you have been added to CloudMedic by an administrator.\n\nPlease login with your assigned username and password:\n\nUsername: "******"\nPassword: "******"\n\n After logging in, change your password under the profile tab.";
sender.SendInvite(mailBody, user.Email);
return(Created("users/" + user.Id, ToDto.UserToDto(user)));
}
public async Task <IHttpActionResult> GetMedications()
{
List <Medication> medications;
medications = await db.Medication
.Take(30)
.ToListAsync();
var medicationsDto = new List <MedicationDto>();
foreach (var medication in medications)
{
medicationsDto.Add(ToDto.MedicationToDto(medication));
}
return(Ok(medicationsDto));
}
public async Task <IHttpActionResult> GetPrescriptions(string id)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var prescriptionsDto = new List <PrescriptionDto>();
foreach (var prescription in user.Prescriptions)
{
prescriptionsDto.Add(ToDto.PrescriptionToDto(prescription));
}
return(Ok(prescriptionsDto));
}
public async Task <IHttpActionResult> GetPatientCareTeams(string id)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var careTeamsDto = new List <CareTeamDto>();
var roles = await _db.Roles.ToDictionaryAsync(r => r.Id);
foreach (var careTeam in user.PatientCareTeams)
{
careTeamsDto.Add(ToDto.CareTeamToDto(careTeam, roles));
}
return(Ok(careTeamsDto));
}
public async Task <IHttpActionResult> GetPrescriptions(string providerId)
{
var provider = await userManager.FindByIdAsync(providerId);
if (provider == null)
{
return(NotFound());
}
List <PrescriptionDto> prescriptionsDto = new List <PrescriptionDto>();
foreach (var careTeam in provider.ProviderCareTeams)
{
foreach (var prescription in careTeam.Patient.Prescriptions)
{
prescriptionsDto.Add(ToDto.PrescriptionToDto(prescription));
}
}
return(Ok(prescriptionsDto));
}
public async Task <IHttpActionResult> GetCareTeams()
{
List <CareTeam> careTeams;
//TODO: Add pagination to support over 30 care teams
careTeams = await db.CareTeam
.Take(30)
.ToListAsync();
var careTeamsDto = new List <CareTeamDto>();
var roles = await db.Roles.ToDictionaryAsync(r => r.Id);
foreach (var careTeam in careTeams)
{
careTeamsDto.Add(ToDto.CareTeamToDto(careTeam, roles));
}
return(Ok(careTeamsDto));
}
public async Task <IHttpActionResult> PostCareTeam(CareTeamBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var patient = await userManager.FindByIdAsync(model.PatientId);
if (patient == null)
{
return(NotFound());
}
List <ApplicationUser> providers = new List <ApplicationUser>();
foreach (string ProviderId in model.ProviderIds)
{
var provider = await userManager.FindByIdAsync(ProviderId);
if (provider == null)
{
return(NotFound());
}
providers.Add(provider);
}
List <ApplicationUser> supporters = new List <ApplicationUser>();
foreach (string SupporterId in model.SupporterIds)
{
var supporter = await userManager.FindByIdAsync(SupporterId);
if (supporter == null)
{
return(NotFound());
}
supporters.Add(supporter);
}
var careTeam = new CareTeam()
{
Id = Guid.NewGuid(),
Name = model.Name,
Active = false,
Providers = providers,
Supporters = supporters,
Patient = patient
};
db.CareTeam.Add(careTeam);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (CareTeamExists(careTeam.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(Created("CareTeams/" + careTeam.Id, ToDto.CareTeamToDto(careTeam)));
}
public async Task <IHttpActionResult> GetUsers(int page = 1, string role = null)
{
List <ApplicationUser> users;
// Variables initialized depending on whether role specified
int totalUsers;
int maxPage;
int skipUsers;
// If no role specified, just query the last 30 users
if (string.IsNullOrWhiteSpace(role))
{
totalUsers = await _db.Users.CountAsync();
// The maximum number of pages, rounded up
maxPage = ((totalUsers + pageSize + 1) / pageSize);
page = Math.Max(1, page);
page = Math.Min(maxPage, page);
skipUsers = (page - 1) * pageSize;
users = await _db.Users
.OrderBy(u => u.Id)
.Include(u => u.Roles)
.Skip(skipUsers)
.Take(pageSize)
.ToListAsync();
}
else
{
var roleId = RoleManager.GetRoleIdFromRoleName(role);
totalUsers = await _db.Users
.Where(u => u.Roles.Any(r => r.RoleId == roleId))
.CountAsync();
// The maximum number of pages, rounded up
maxPage = ((totalUsers + pageSize - 1) / pageSize);
page = Math.Max(1, page);
page = Math.Min(maxPage, page);
skipUsers = (page - 1) * pageSize;
users = await _db.Users
.Where(u => u.Roles.Any(r => r.RoleId == roleId))
.OrderBy(u => u.Id)
.Include(u => u.Roles)
.Skip(skipUsers)
.Take(pageSize)
.ToListAsync();
}
UsersPageDto result = new UsersPageDto()
{
Users = new List <UserDto>(),
HasNext = (page < maxPage),
HasPrev = (page > 1),
NumPages = maxPage,
CurrentCount = totalUsers
};
// Convert the user objects to a list of serializable data transfer objects
foreach (var user in users)
{
result.Users.Add(ToDto.UserToDto(user));
}
return(Ok(result));
}
