internal static List <ScheduleHistory> GetScheduleHistory(int accountId)
{
List <ScheduleHistory> modelList = new List <ScheduleHistory>();
using (DBConnector connector = new DBConnector("get_ScheduleHistory", CommandType.StoredProcedure))
{
connector.Cmd.Parameters.AddWithValue("@AccountID", accountId);
connector.Execute(DBOperation.GetWhileReader);
if (connector.Rdr.HasRows)
{
while (connector.Rdr.Read())
{
ScheduleHistory model = new ScheduleHistory();
model.UserName = connector.Rdr["UserName"].ToString();
model.Avatar = connector.Rdr["Avatar"].ToString();
model.MedicineName = connector.Rdr["MedicineName"].ToString();
model.MedicineDateTime = (DateTime)connector.Rdr["MedicineDateTime"];
model.Active = (bool)connector.Rdr["Active"];
modelList.Add(model);
}
}
}
return(modelList);
}
private void HousekeepSchedules()
{
_scheduleRepo = _scope.ServiceProvider.GetRequiredService <IAppRepository>();
if (_scheduleRepo.GetScheduleCount() == 0)
{
NeedToGenerateNewSchedule = true;
return;
}
var latestScheduleRecord = _scheduleRepo.GetLatestScheduleRecord();
if (latestScheduleRecord < FirstWorkingDayDate)
{
var scheduleHistoryItems = new List <ScheduleHistory>();
var existingSchedules = _scheduleRepo.GetAllSchedules();
foreach (var existingSchedule in existingSchedules)
{
ScheduleHistory shItem = new ScheduleHistory();
shItem.PreviousId = existingSchedule.Id;
shItem.Shift = existingSchedule.Shift;
shItem.StaffId = existingSchedule.StaffId;
shItem.Date = existingSchedule.Date;
scheduleHistoryItems.Add(shItem);
}
_scheduleRepo.AddToHistory(scheduleHistoryItems);
_scheduleRepo.DeleteAllSchedules();
NeedToGenerateNewSchedule = true;
}
else
{
NeedToGenerateNewSchedule = false;
}
}
public bool ScheduleActivity(ScheduledActivity scheduledActivity, bool doneToday, bool repeatable, bool multiDorm)
{
if (doneToday)
{
Options = 0;
AvailableToday = false;
}
else if (!scheduledActivity.HasOther)
{
--Options;
}
ScheduleHistory.Add(scheduledActivity.Abbreviation);
bool soloTracker = ThisDorm == Dorm;
if (repeatable && (!soloTracker || multiDorm))
{
if (!PreviousRepeatableActivities.Add(scheduledActivity.Activity))
{
throw new NotImplementedException("Did a repeatable activity twice with the same Dorm.");
}
}
if (!soloTracker && --Priority == 0)
{
Options = 0;
AvailableToday = false;
return(true);
}
return(false);
}
public void CreateHitory(Scheduler sch, string response)
{
var scheduleHistory = new ScheduleHistory
{
HistoryDateTime = DateTime.Now,
Response = response,
ScheduleId = sch.ScheduleId
};
_history.Add(scheduleHistory);
sch.State = Db.Abstractions.MaintananceState.Modified;
sch.NextDateTime = sch.LatestNextDateTime;
Update(sch);
_context.SaveChangesAsync().Wait();
}
public void ClearFromHistory(ScheduledActivity scheduledActivity, bool repeatable, bool multiDorm)
{
bool soloTracker = ThisDorm == Dorm;
if (!soloTracker)
{
++Priority;
AvailableToday = true;
}
if (repeatable && (!soloTracker || multiDorm))
{
if (!PreviousRepeatableActivities.Remove(scheduledActivity.Activity))
{
throw new NotImplementedException("Activity not found in PreviousRepeatableActivities.");
}
}
ScheduleHistory.Remove(scheduledActivity.Abbreviation);
}
public void ScheduleActivity(ActivityInfo activity, ScheduledActivity scheduledActivity)
{
if (!activity.Flags.HasFlag(ActivityFlags.Manual) && (!activity.Flags.HasFlag(ActivityFlags.Exclusive) || !activity.Flags.HasFlag(ActivityFlags.Excess)))
{
TotalScheduledDuration += activity.Duration;
}
else
{
TotalManualDuration += activity.Duration;
}
bool repeatable = activity.Flags.HasFlag(ActivityFlags.Repeatable);
bool multiDorm = activity.Flags.HasFlag(ActivityFlags.MultiDorm);
AvailableActivitiesToday.Remove(activity.ID);
if (multiDorm)
{
AvailableMultiDormActivitiesToday.Remove(activity.ID);
}
bool clear = !repeatable;
if (repeatable)
{
if (!RepeatableHistory.Add(activity.ID))
{
clear = true;
}
else
{
if (ActivityPriorities.TryGetValue(activity.ID, out int activityPriority))
{
if (--activityPriority == 0)
{
ActivityPriorities.Remove(activity.ID);
}
}
else
{
ActivityPriorities.Add(activity.ID, -1);
}
}
/*if (!RepeatableTodayHistory.Add(activity.ID))
* throw new IndexOutOfRangeException("Activity repeated twice the same day.");*/
}
if (clear)
{
AvailableActivities.Remove(activity.ID);
if (multiDorm)
{
AvailableMultiDormActivities.Remove(activity.ID);
}
}
ActivitiesDoneToday.Add(activity.ID);
if (activity.IncompatibleActivities.Any())
{
AvailableActivitiesToday.ExceptWith(activity.IncompatibleActivities);
AvailableMultiDormActivitiesToday.ExceptWith(activity.IncompatibleActivities);
}
ScheduleHistory.Add(scheduledActivity.Abbreviation);
if (scheduledActivity.HasOther)
{
if (scheduledActivity.Dorm == Dorm)
{
if (
DormPriorities.TryGetValue(
scheduledActivity.OtherDorm,
out InterDormTracking otherDorm
) && otherDorm.ScheduleActivity(
scheduledActivity,
!OtherDormsDoneToday.Add(scheduledActivity.OtherDorm),
repeatable, multiDorm
)
)
{
UsedUpOtherDorms.Add((InterDormTracking)otherDorm.Clone());
DormPriorities.Remove(scheduledActivity.OtherDorm);
}
}
}
else
{
DormPriorities[Dorm].ScheduleActivity(scheduledActivity, false, repeatable, multiDorm);
OtherDormsDoneToday.Add(Dorm);
}
}
internal void ClearFromHistory(ScheduledActivity scheduledActivity, bool ignoreHasOther = false)
{
ScheduleHistory.Remove(scheduledActivity.Abbreviation);
var activity = Schedule.Activities[scheduledActivity.Activity];
bool repeatable = activity.Flags.HasFlag(ActivityFlags.Repeatable);
bool multiDorm = activity.Flags.HasFlag(ActivityFlags.MultiDorm);
if (activity.IncompatibleActivities.Any())
{
var incompat = new SortedSet <int>(activity.IncompatibleActivities);
incompat.ExceptWith(ActivitiesDoneToday);
if (incompat.Any())
{
AvailableActivitiesToday.UnionWith(incompat);
AvailableMultiDormActivitiesToday.UnionWith(incompat.Intersect(ActivityInfo.MultiDormActivities));
}
}
ActivitiesDoneToday.Remove(activity.ID);
if (scheduledActivity.HasOther)
{
if (!ignoreHasOther)
{
if (!DormPriorities.TryGetValue(scheduledActivity.OtherDorm, out InterDormTracking interDorm))
{
var index = UsedUpOtherDorms.FindIndex(d => d.Dorm == scheduledActivity.OtherDorm);
interDorm = (InterDormTracking)UsedUpOtherDorms[index].Clone();
UsedUpOtherDorms.RemoveAt(index);
DormPriorities.Add(scheduledActivity.OtherDorm, interDorm);
}
interDorm.ClearFromHistory(scheduledActivity, repeatable, multiDorm);
OtherDormsDoneToday.Remove(scheduledActivity.OtherDorm);
}
}
else
{
DormPriorities[Dorm].ClearFromHistory(scheduledActivity, repeatable, multiDorm);
OtherDormsDoneToday.Remove(Dorm);
}
if (repeatable)
{
if (RepeatableHistory.Contains(activity.ID))
{
// if it wasn't cleared, it was the first time the activity was done by that dorm
if (!AvailableActivities.Add(activity.ID))
{
RepeatableHistory.Remove(activity.ID);
}
if (multiDorm)
{
AvailableMultiDormActivities.Add(activity.ID);
}
RepeatableTodayHistory.Remove(activity.ID);
}
else
{
throw new NotImplementedException("Activity being cleared hasn't been undergone.");
}
if (ActivityPriorities.TryGetValue(activity.ID, out int activityPriority))
{
if (++activityPriority == 0)
{
ActivityPriorities.Remove(activity.ID);
}
}
else
{
ActivityPriorities.Add(activity.ID, 1);
}
}
else
{
if (!AvailableActivities.Add(activity.ID))
{
throw new NotImplementedException("Activity being cleared hasn't been undergone.");
}
if (multiDorm)
{
AvailableMultiDormActivities.Add(activity.ID);
}
}
AvailableActivitiesToday.Add(activity.ID);
if (multiDorm)
{
AvailableMultiDormActivitiesToday.Add(activity.ID);
}
if (!activity.Flags.HasFlag(ActivityFlags.Manual) && (!activity.Flags.HasFlag(ActivityFlags.Exclusive) || !activity.Flags.HasFlag(ActivityFlags.Excess)))
{
TotalScheduledDuration -= activity.Duration;
}
else
{
TotalManualDuration -= activity.Duration;
}
}
internal void FetchScheduleHistory(ScheduleHistory history, SafeDataReader dr)
{
history.Id = dr.GetInt32("Id");
history.ScheduleName = dr.GetString("ScheduleName");
history.Parameter = dr.GetString("Parameter");
history.ScheduleDescription = dr.GetString("ScheduleDescription");
history.RunbySystem = dr.GetString("RunbySystem");
history.LatRunOn = dr.GetDateTime("LatRunOn").ToString("dd MMM yyyy hh:mm:ss tt");
}
public static List<ScheduleHistory> GetScheduleHistory()
{
List<ScheduleHistory> history = new List<ScheduleHistory>();
System.Diagnostics.StackFrame stackFrame = new System.Diagnostics.StackFrame();
System.Reflection.MethodBase methodBase = stackFrame.GetMethod();
log.Debug("Start: " + methodBase.Name);
var reader = SqlHelper.ExecuteReader(ConnectionUtility.GetConnectionString(), CommandType.StoredProcedure, "SPGetScheduleHistory");
var safe = new SafeDataReader(reader);
while (reader.Read())
{
var detail = new ScheduleHistory();
detail.FetchScheduleHistory(detail, safe);
history.Add(detail);
}
log.Debug("End: " + methodBase.Name);
return history;
}
public ApplyCategoryPriceRules(ScheduleHistory scheduleHistory)
: base()
{
base.TaskRecordItem = scheduleHistory;
}
