/// <summary>
/// Updates the Scheduled QuestionnaireDate
/// </summary>
/// <param name="scheduledQuestionnaire">The schedules questionnaire to update</param>
public void UpdateScheduleQuestionnaireDate(ScheduledQuestionnaireDate scheduledQuestionnaire)
{
this.context.Entry(scheduledQuestionnaire).State = EntityState.Modified;
this.context.Entry(scheduledQuestionnaire.ResponseGroup).State = EntityState.Unchanged;
this.context.Entry(scheduledQuestionnaire.AssignedQuestionnaire).State = EntityState.Unchanged;
this.context.SaveChanges();
}
/// <summary>
/// Schedules a questionnaire date for a AssignedQuestionnaire
/// </summary>
/// <param name="questionnaireName">The name of the questionnaire to schedule</param>
/// <param name="aq">the AssignedQuestionnaire class it will belong to</param>
/// <param name="calculatedDate">The date and time that has been calculated</param>
/// <param name="scheduleString"> The schedule string that resulted in this date and time</param>
/// <returns>The schedule questionnaire date instance</returns>
public ScheduledQuestionnaireDate ScheduleDateForQuestionnaire(string questionnaireName, AssignedQuestionnaire aq, DateTime calculatedDate, string scheduleString)
{
ScheduledQuestionnaireDate sqd = new ScheduledQuestionnaireDate();
sqd.AssignedQuestionnaire = this.context.AssignedQuestionnaires.Where(a => a.Id == aq.Id).Single();
sqd.ScheduleHasBeenExecuted = false;
sqd.CalculatedDate = calculatedDate;
sqd.ScheduleString = scheduleString;
this.context.ScheduledQuestionnaireDates.Add(sqd);
this.context.SaveChanges();
return(sqd);
}
/// <summary>
/// Scheduler for demo purposes. An Assigned Questionnaire is scheduled when there are no non-completed QuestionnaireUserResponseGroups
/// </summary>
public static void ScheduleQuestionnairesForDemo()
{
AccessHandlerManager ahm = new AccessHandlerManager();
List <AssignedQuestionnaire> questionnaires = ahm.EpisodeAccessHandler.GetAssignedQuestionnaires();
foreach (AssignedQuestionnaire aq in questionnaires)
{
if (aq.Schedules.Where(s => s.ResponseGroup != null && !s.ResponseGroup.Completed).Count() == 0)
{
ScheduledQuestionnaireDate sqd = ahm.EpisodeAccessHandler.ScheduleDateForQuestionnaire(aq.QuestionnaireName, aq, DateTime.Now, aq.ScheduleString);
ahm.QuestionnaireAccessHandler.CreateQuestionnaireUserResponseGroup(aq.Episode.Patient.Id, aq.QuestionnaireName, null, sqd);
}
}
}
/// <summary>
/// Creates a User Response Group for the given user and Questionnaire Name
/// </summary>
/// <param name="patientId">The id of the Patient</param>
/// <param name="questionnaireName">The name of the questionnaire</param>
/// <param name="formatName">the name of the format to create the response group for. If null the default format name of the questionnaire is used</param>
/// <param name="sqd">The optional scheduled questionniare date that the user responsegroup must belong to</param>
/// <returns>The newly created QuestionnaireUserResponseGroup</returns>
public QuestionnaireUserResponseGroup CreateQuestionnaireUserResponseGroup(string patientId, string questionnaireName, string formatName, ScheduledQuestionnaireDate sqd)
{
QuestionnaireUserResponseGroup group = new QuestionnaireUserResponseGroup();
group.Patient = this.context.Patients.Where(u => u.Id == patientId).Single();
group.Questionnaire = this.context.Questionnaires.Where(q => q.Name == questionnaireName).OrderByDescending(q => q.Id).First();
group.QuestionnaireFormatName = formatName == null ? group.Questionnaire.DefaultFormatName : formatName;
group.DatetimeCreated = DateTime.Now;
group.Status = QuestionnaireUserResponseGroupStatus.New;
group.ScheduledQuestionnaireDate = sqd == null ? null : this.context.ScheduledQuestionnaireDates.Where(s => s.Id == sqd.Id).Single();
this.context.QuestionnaireUserResponseGroups.Add(group);
this.context.SaveChanges();
new NotificationHandler(this.context).CreateNotification(NotificationType.NewQuestionnaire, group.Id);
return(group);
}
/// <summary>
/// Runs through the schedules available and checks which Questionnairs must be assigned.
/// </summary>
public static void ScheduleQuestionnaires()
{
AccessHandlerManager ahm = new AccessHandlerManager();
List <AssignedQuestionnaire> questionnaires = ahm.EpisodeAccessHandler.GetAssignedQuestionnaires();
foreach (AssignedQuestionnaire aq in questionnaires)
{
var milestones = aq.Episode.MileStones.GroupBy(m => m.Milestone.Name.ToLower()).ToDictionary(k => k.Key, v => (IEnumerable <DateTime>)v.Select(m => m.MilestoneDate).ToList());
var scheduledDates = new ScheduleParser().ParseSchedule(aq.ScheduleString, aq.Episode.DateCreated, milestones);
/*
* foreach (var scheduled in aq.Schedules)
* {
* if (scheduled.ResponseGroup != null && scheduled.ResponseGroup.Status == QuestionnaireUserResponseGroupStatus.New && (!scheduledDates.ContainsKey(scheduled.ScheduleString) || !scheduledDates[scheduled.ScheduleString].Contains(scheduled.CalculatedDate.Value)))
* {
* // TODO should we remove?
* }
* }*/
// Find which dates we have to schedule
List <ToSchedule> toSchedule = new List <ToSchedule>();
var schedules = aq.Schedules.GroupBy(s => s.ScheduleString).ToDictionary(k => k.Key, v => v.Select(s => s.CalculatedDate).ToList());
foreach (var dates in scheduledDates)
{
if (!schedules.ContainsKey(dates.Key))
{
foreach (DateTime date in dates.Value)
{
toSchedule.Add(new ToSchedule()
{
ScheduleString = dates.Key, DateTimeToSchedule = date
});
}
}
else
{
foreach (DateTime date in dates.Value)
{
if (!schedules[dates.Key].Contains(date))
{
toSchedule.Add(new ToSchedule()
{
ScheduleString = dates.Key, DateTimeToSchedule = date
});
}
}
}
}
// Create the new ScheduledQuestionnaireDate instances
List <ScheduledQuestionnaireDate> newSchedules = new List <ScheduledQuestionnaireDate>();
foreach (ToSchedule ts in toSchedule)
{
ScheduledQuestionnaireDate sqd = ahm.EpisodeAccessHandler.ScheduleDateForQuestionnaire(aq.QuestionnaireName, aq, ts.DateTimeToSchedule, ts.ScheduleString);
newSchedules.Add(sqd);
}
newSchedules.AddRange(aq.Schedules.Where(s => s.ScheduleHasBeenExecuted = false));
if (newSchedules.Count > 0)
{
newSchedules.OrderBy(s => s.CalculatedDate);
// Schedule the last one that is not schedule and after this date
DateTime today = DateTime.Now;
var lastEntry = newSchedules.Where(s => s.CalculatedDate < today).OrderBy(s => s.CalculatedDate).LastOrDefault();
if (lastEntry != null)
{
ahm.QuestionnaireAccessHandler.CreateQuestionnaireUserResponseGroup(aq.Episode.Patient.Id, aq.QuestionnaireName, null, lastEntry);
lastEntry.ScheduleHasBeenExecuted = true;
ahm.EpisodeAccessHandler.UpdateScheduleQuestionnaireDate(lastEntry);
}
// Mark all the other ones as not completed
var toDisable = newSchedules.Where(s => s.CalculatedDate < (lastEntry != null ? lastEntry.CalculatedDate : today));
foreach (var sqd in toDisable)
{
sqd.ScheduleHasBeenExecuted = true;
ahm.EpisodeAccessHandler.UpdateScheduleQuestionnaireDate(sqd);
if (sqd.ResponseGroup != null)
{
ahm.QuestionnaireAccessHandler.SaveQuestionnaireResponse(sqd.ResponseGroup.Questionnaire.Id, sqd.ResponseGroup.Id, true, new List <QuestionnaireResponse>(), QuestionnaireUserResponseGroupStatus.Missed);
}
}
}
}
}
