public async Task <string> MakeRandomUsersAsync()
{
List <User> users = new List <User>();
for (int i = 1; i <= 100; i++)
{
users.Add(new User
{
Username = "******" + i,
FirstName = "firstname" + i,
LastName = "lastname" + i,
Degree = "nodegree",
Password = CryptHelper.HashPassowrd("password" + i),
Email = "user" + i + "@email.pl",
CreatedAt = DateTime.Now,
UpdatedAt = DateTime.Now,
Roles = "participant;",
AccessFailedCount = 0,
IsDeleted = false,
IsEncrypted = false
});
}
await _context.Users.AddRangeAsync(users);
await _context.SaveChangesAsync();
return("Done");
}
/// TODO: MOVE
public static async Task <bool> AddStickyNote(DbCtx ctx, string patientApiKey, JObject stickyJson)
{
try
{
string stickyContent = (string)stickyJson["content"];
float stickyScale = (float)stickyJson["scale"];
if (!(string.IsNullOrWhiteSpace(stickyContent) || stickyScale == 0))
{
Patient patient = (Patient)GetEntityByForeignKey(ctx, patientApiKey, Collection.patients);
StickyNote stickyNote = new StickyNote()
{
PatientId = patient.Id, Scale = stickyScale, Content = stickyContent
};
patient.Stickies.Add(stickyNote);
await ctx.SaveChangesAsync();
return(true);
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(false);
}
public static async Task <bool> CreatePatientActivityLog(DbCtx ctx, string patientApiKey, JObject logJson)
{
try
{
var jsonDict = JObject.FromObject(logJson).ToObject <Dictionary <string, object> >();
string caption = (string)jsonDict["Caption"];
string description = (string)jsonDict["JsonDescription"];
string location = (string)jsonDict["Location"];
ActivityLog log = new ActivityLog()
{
Caption = caption, JsonDescription = description, Location = location, DateTime = DateTime.Now
};
Patient patient = (Patient)GetEntityByForeignKey(ctx, patientApiKey, Collection.patients);
patient.ActivityLogs.Add(log);
await ctx.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(false);
}
/// TODO: MOVE
public static async Task <bool> MessagePatient(DbCtx ctx, string carerApiKey, string patientId, JObject messageJson)
{
try
{
var jsonDict = JObject.FromObject(messageJson).ToObject <Dictionary <string, object> >();
string title = (string)jsonDict["Title"];
string message = (string)jsonDict["Message"];
Carer carer = (Carer)GetEntityByForeignKey(ctx, carerApiKey, Collection.carers);
if (carer != null)
{
Patient patient = (Patient) await GetEntityByPrimaryKey(ctx, patientId, Collection.patients);
if (patient != null)
{
PatientMessage messageObj = new PatientMessage()
{
Read = null, Sent = DateTime.Now, Title = title, Message = message, CarerId = carer.Email
};
patient.Messages.Add(messageObj);
await ctx.SaveChangesAsync();
return(true);
}
}
return(false);
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
}
/// TODO: MOVE
public static async Task <bool> AllocatePatient(DbCtx ctx, JObject patientAndCarerId)
{
try
{
string patientId = (string)patientAndCarerId["patient"];
string carerEmail = (string)patientAndCarerId["carer"];
bool assign = (bool)patientAndCarerId["assign"]; // Whether to assign or unassign.
Patient patient = (Patient) await GetEntityByPrimaryKey(ctx, patientId, Collection.patients);
Carer carer = (Carer) await GetEntityByPrimaryKey(ctx, carerEmail, Collection.carers);
bool patientAlreadyAssigned = carer.AssignedPatientIds.Contains(patientId);
if (assign)
{
// Assign the patient to the carer if they are not assigned.
if (!patientAlreadyAssigned)
{
carer.AssignedPatientIds += "," + patientId;
await ctx.SaveChangesAsync();
}
}
else
{
// Unassign the patient from the carer if they are assigned..
if (patientAlreadyAssigned)
{
if (patientId != "testpatient") // Don't remove test record.
{
// Awkward string ops because efcore doesn't allow for simply storing lists of strings.
carer.AssignedPatientIds = carer.AssignedPatientIds.Replace(patientId, "");
carer.AssignedPatientIds = carer.AssignedPatientIds.Replace(",,", ""); // Remove any residual comma pairs.
carer.AssignedPatientIds = carer.AssignedPatientIds.TrimEnd(','); // Remove end comma if no value follows.
carer.AssignedPatientIds = carer.AssignedPatientIds.TrimStart(','); // Remove start comma if no value follows.
}
await ctx.SaveChangesAsync();
}
}
return(true);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(false);
}
/// TODO: IMPLEMENT
public static async Task <bool> UpdatePatientConfig(DbCtx ctx, string patientId, JObject configJson)
{
try
{
var jsonDict = JObject.FromObject(configJson).ToObject <Dictionary <string, object> >();
Patient patient = (Patient) await GetEntityByPrimaryKey(ctx, patientId, Collection.patients);
bool changes = false;
foreach (string key in jsonDict.Keys)
{
switch (key.ToLower())
{
case "inputs":
//int age = (int)(long)jsonDict["Age"];
//patient.Config.EnabledFeatures = (PatientNotes.AgeRange)age;
changes = true;
break;
case "falldetection":
changes = true;
break;
case "roomdetection":
changes = true;
break;
case "confusiondetection":
changes = true;
break;
case "stickynotes":
changes = true;
break;
}
}
if (changes)
{
await ctx.SaveChangesAsync();
return(true);
}
return(false);
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
}
public async Task <string> RegisterStudentAsync(RegisterUserViewModel user)
{
var student = new User
{
FirstName = user.FirstName,
LastName = user.LastName,
UserName = user.Username,
Email = user.Email
};
var param = ctx.RegisterLinkParams.Where(p => p.LinkParameter.ToString() == user.RegisterToken).SingleOrDefault();
if (param != null)
{
var result = await userManager.CreateAsync(student);
if (result.Succeeded)
{
var res = await userManager.AddToRoleAsync(student, Role.Student.ToString());
if (res.Succeeded)
{
ctx.RegisterLinkParams.Remove(param);
await ctx.SaveChangesAsync();
return(res.Succeeded.ToString());
}
return(res.Errors.FirstOrDefault().Description);
}
return(result.Errors.FirstOrDefault().Description);
}
return("Invalid Token");
}
/// TODO: MOVE
public static async Task <bool> UpdatePatientNotes(DbCtx ctx, string patientId, JObject notesJson)
{
try
{
var jsonDict = JObject.FromObject(notesJson).ToObject <Dictionary <string, object> >();
Patient patient = (Patient) await GetEntityByPrimaryKey(ctx, patientId, Collection.patients);
bool changes = false;
foreach (string key in jsonDict.Keys)
{
switch (key.ToLower())
{
case "age":
int age = (int)(long)jsonDict["Age"];
patient.Notes.Age = (PatientNotes.AgeRange)age;
changes = true;
break;
case "diagnosis":
int diagnosis = (int)(long)jsonDict["Diagnosis"];
patient.Notes.Diagnosis = (PatientNotes.Severity)diagnosis;
changes = true;
break;
case "notes":
string notes = (string)jsonDict["Notes"];
patient.Notes.Notes = (string)notes;
changes = true;
break;
}
}
if (changes)
{
await ctx.SaveChangesAsync();
return(true);
}
return(false);
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
}
/// TODO: MOVE
public static async Task <bool> ChangeCarerPermission(DbCtx ctx, JObject carerAndRole)
{
try
{
string carerEmail = (string)carerAndRole["email"];
string role = (string)carerAndRole["role"];
Carer carer = (Carer) await GetEntityByPrimaryKey(ctx, carerEmail, Collection.carers);
carer.User.Role = role;
await ctx.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(false);
}
/// TODO: MOVE
public static async Task <bool> UpdateStickyNote(DbCtx ctx, string stickyId, JObject stickyJson)
{
try
{
StickyNote sticky = (StickyNote) await GetEntityByPrimaryKey(ctx, stickyId, Collection.stickies);
var jsonDict = JObject.FromObject(stickyJson).ToObject <Dictionary <string, object> >();
bool changes = false;
foreach (string key in jsonDict.Keys)
{
switch (key.ToLower())
{
case "content":
string content = (string)jsonDict[key];
sticky.Content = content;
changes = true;
break;
case "scale":
float scale = (float)(double)jsonDict[key];
sticky.Scale = scale;
changes = true;
break;
}
}
if (changes)
{
await ctx.SaveChangesAsync();
return(true);
}
return(false);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(false);
}
/// TODO: MOVE
public static async Task <bool> AddCalendarEntry(DbCtx ctx, string patientId, Dictionary <string, object> jsonDict)
{
try
{
DateTime start;
DateTime end;
try
{
// DateTime in string format.
start = DateTime.Parse((string)jsonDict["Start"]);
bool endProvided = DateTime.TryParse((string)jsonDict["End"], out end);
if (!endProvided)
{
end = start;
}
}
catch
{
// DateTime object.
start = (DateTime)jsonDict["Start"];
end = (DateTime)jsonDict["End"];
}
int repetition = (int)(long)jsonDict["Repeat"];
string description = (string)jsonDict["Description"];
string reminders = (string)jsonDict["Reminders"];
Patient patient = (Patient) await GetEntityByPrimaryKey(ctx, patientId, Collection.patients);
CalendarEntry entry = new CalendarEntry()
{
Description = description, End = end, Start = start, Repeat = (CalendarEntry.Repetition)repetition, Reminders = reminders
};
patient.CalendarEntries.Add(entry);
await ctx.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(false);
}
public static async Task <bool> DeleteEntityByPrimaryKey(DbCtx ctx, string key, Collection collection)
{
try
{
IEntity e = await GetEntityByPrimaryKey(ctx, key, collection);
if (key != "testpatient" && key != "testcarer") // Avoid deleting test entries.
{
switch (collection)
{
case Collection.patients:
ctx.Users.Remove((e as Patient).User);
break;
case Collection.carers:
ctx.Users.Remove((e as Carer).User);
break;
case Collection.calendars:
ctx.Calendars.Remove(e as CalendarEntry);
break;
case Collection.stickies:
ctx.Stickies.Remove(e as StickyNote);
break;
default:
throw new Exception("Unknown table.");
}
}
await ctx.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
Console.WriteLine("Unexpected error: " + e.Message);
}
return(false);
}
/// TODO: MOVE
public static async Task <bool> CreateUser(DbCtx ctx, string primaryKey, User.UserRole role)
{
try
{
User user = new User()
{
Role = role.ToString()
};
await ctx.Users.AddAsync(user);
if (role == User.UserRole.patient)
{
Patient patient = new Patient()
{
User = user, Id = primaryKey
};
await ctx.Patients.AddAsync(patient);
}
else
{
Carer carer = new Carer()
{
User = user, Email = primaryKey
};
await ctx.Carers.AddAsync(carer);
}
await ctx.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(false);
}
/// TODO: MOVE
public static async Task <bool> UpdateCalendarEntry(DbCtx ctx, string calendarId, Dictionary <string, object> jsonDict)
{
try
{
CalendarEntry entry = await ctx.Calendars.FindAsync(calendarId);
bool changes = false;
foreach (string key in jsonDict.Keys)
{
switch (key.ToLower())
{
case "start":
DateTime start;
try
{
// DateTime in string format.
start = DateTime.Parse((string)jsonDict["Start"]);
}
catch
{
// DateTime object.
start = (DateTime)jsonDict["Start"];
}
entry.Start = start;
changes = true;
break;
case "end":
DateTime end;
try
{
// DateTime in string format.
end = DateTime.Parse((string)jsonDict["End"]);
}
catch
{
// DateTime object.
end = (DateTime)jsonDict["End"];
}
entry.End = end;
changes = true;
break;
case "repeat":
int repetition = (int)(long)jsonDict["Repeat"];
entry.Repeat = (CalendarEntry.Repetition)repetition;
changes = true;
break;
case "description":
string description = (string)jsonDict["Description"];
entry.Description = description;
changes = true;
break;
case "reminders":
string reminders = (string)jsonDict["Reminders"];
entry.Reminders = reminders;
changes = true;
break;
}
}
if (changes)
{
await ctx.SaveChangesAsync();
return(true);
}
return(false);
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
}
public async Task DeleteAsync(T entity)
{
dbSet.Remove(entity);
await ctx.SaveChangesAsync();
}
public async Task CommitAsync() => await _context.SaveChangesAsync();
