public InListOutOfList(List<SubCalendarEvent> FullList, List<List<List<SubCalendarEvent>>> AllMyList, List<TimeLine> MyFreeSpots)
{
DictData_TimeLine = new Dictionary<List<TimeLine>, List<SubCalendarEvent>>();
foreach (List<List<SubCalendarEvent>> ListToCheck in AllMyList)
{
List<SubCalendarEvent> TotalList = new List<SubCalendarEvent>();
int i = 0;
List<TimeLine> timeLineEntry = new List<TimeLine>();
foreach (List<SubCalendarEvent> myList in ListToCheck)
{
TimeLine myTimeLine = new TimeLine(MyFreeSpots[i].Start, MyFreeSpots[i].End);
TotalList.AddRange(myList);
TimeSpan TotalTimeSpan = new TimeSpan(0);
foreach (SubCalendarEvent mySubEvent in myList)
{
TotalTimeSpan=TotalTimeSpan.Add(mySubEvent.ActiveSlot.BusyTimeSpan);
}
BusyTimeLine EffectivebusySlot = new BusyTimeLine("1000000_1000001", MyFreeSpots[i].Start, MyFreeSpots[i].Start.Add(TotalTimeSpan));
myTimeLine.AddBusySlots(EffectivebusySlot);
timeLineEntry.Add(myTimeLine);
i++;
}
DictData_TimeLine.Add(timeLineEntry, Utility.NotInList_NoEffect(FullList, TotalList));
}
}
public SubCalendarEvent(string MySubEventID, DateTime EventStart, DateTime EventDeadline, BusyTimeLine SubEventBusy, bool Rigid, bool Enabled, EventDisplay UiParam, MiscData Notes, bool completeFlag, Location EventLocation = null, TimeLine RangeOfSubCalEvent = null)
{
CalendarEventRange = RangeOfSubCalEvent;
SubEventID = new EventID(MySubEventID.Split('_'));
StartDateTime = EventStart;
EndDateTime = EventDeadline;
EventDuration = SubEventBusy.TimelineSpan;
BusyFrame = SubEventBusy;
RigidSchedule = Rigid;
this.Enabled = Enabled;
this.EventLocation = EventLocation;
UiParams = UiParam;
DataBlob = Notes;
Complete = completeFlag;
}
public SubCalendarEvent(string MySubEventID, BusyTimeLine MyBusylot, DateTime EventStart, DateTime EventDeadline, TimeSpan EventPrepTime, string myParentID, bool Rigid,bool Enabled, EventDisplay UiParam, MiscData Notes, bool completeFlag, Location EventLocation = null, TimeLine RangeOfSubCalEvent = null)
{
CalendarEventRange = RangeOfSubCalEvent;
//string eventName, TimeSpan EventDuration, DateTime EventStart, DateTime EventDeadline, TimeSpan EventPrepTime, TimeSpan PreDeadline, bool EventRigidFlag, bool EventRepetition, int EventSplit
StartDateTime = EventStart;
EndDateTime = EventDeadline;
EventDuration = MyBusylot.End - MyBusylot.Start;
BusyFrame = MyBusylot;
PrepTime = EventPrepTime;
SubEventID = new EventID(MySubEventID.Split('_'));
this.EventLocation = EventLocation;
UiParams=UiParam;
DataBlob= Notes;
Complete = completeFlag;
this.Enabled = Enabled;
EventSequence = new EventTimeLine(SubEventID.ToString(), StartDateTime, EndDateTime);
RigidSchedule = Rigid;
}
public SubCalendarEvent(TimeSpan Event_Duration, DateTime EventStart, DateTime EventDeadline, TimeSpan EventPrepTime, string myParentID, bool Rigid, bool Enabled, EventDisplay UiParam,MiscData Notes,bool completeFlag, Location EventLocation =null, TimeLine RangeOfSubCalEvent = null)
{
CalendarEventRange = RangeOfSubCalEvent;
StartDateTime = EventStart;
EndDateTime = EventDeadline;
EventDuration = Event_Duration;
PrepTime = EventPrepTime;
if (myParentID == "16")
{
;
}
UiParams=UiParam;
DataBlob = Notes;
Complete=completeFlag;
SubEventID = new EventID(myParentID + "_" + EventIDGenerator.generate().ToString());
BusyFrame = new BusyTimeLine(this.ID, StartDateTime, EndDateTime);//this is because in current implementation busy frame is the same as CalEvent frame
this.EventLocation = EventLocation;
EventSequence = new EventTimeLine(SubEventID.ToString(), StartDateTime, EndDateTime);
RigidSchedule = Rigid;
this.Enabled = Enabled;
}
/*QUICK SORT SECTION END*/
public BusyTimeLine[] CheckIfMyRangeAlreadyHasSchedule(BusyTimeLine[] BusySlots, SubCalendarEvent MySubEvent)
{
List<BusyTimeLine> InvadingEvents = new List<BusyTimeLine>();
int i = 0;
for (; i < BusySlots.Length; i++)
{
if ((BusySlots[i].End > MySubEvent.Start) && (BusySlots[i].End < MySubEvent.End))
{
InvadingEvents.Add(BusySlots[i]);
}
}
InvadingEvents = SortBusyTimeline(InvadingEvents, true);
return InvadingEvents.ToArray();
}
List<SubCalendarEvent>[] CategorizeSubEventsTimeLine(TimeLine MyRange, BusyTimeLine[] SortedByStartArrayOfBusyTimeLine)//This returns An array of a List of SubCalendarEvents. The function goes through each of the BUsytimeline Events and verifies if its parent calendar Event has a start Time that is eiter earlier than range, within range or start and ends within the range
{
List<SubCalendarEvent>[] ArrayOfDifferentVaryingSubEventsCategories = new List<SubCalendarEvent>[4];
List<CalendarEvent>[] ArrayCalendarEventOfDifferentVaryingSubEventsCategories = new List<CalendarEvent>[4];
List<SubCalendarEvent> MyArrayOfBeforeAndEndsAfterBusyTimelines = new List<SubCalendarEvent>(0);
List<CalendarEvent> MyArrayCalendarEventOfBeforeAndEndsAfterBusyTimelines = new List<CalendarEvent>(0);
List<SubCalendarEvent> MyArrayOfBeforeAndEndsBeforeBusyTimelines = new List<SubCalendarEvent>(0);
List<CalendarEvent> MyArrayCalendarEventOfBeforeAndEndsBeforeBusyTimelines = new List<CalendarEvent>(0);
List<SubCalendarEvent> MyArrayOfStartsAfterAndEndsAfterBusyTimelines = new List<SubCalendarEvent>(0);
List<CalendarEvent> MyArrayCalendarEventOfStartsAfterAndEndsAfterBusyTimelines = new List<CalendarEvent>(0);
List<SubCalendarEvent> MyArrayOfStartsAndEndsBeforeBusyTimelines = new List<SubCalendarEvent>(0);
List<CalendarEvent> MyArrayCalendarEventOfStartsAndEndsBeforeBusyTimelines = new List<CalendarEvent>(0);
int i = 0;
for (; i < SortedByStartArrayOfBusyTimeLine.Length; i++)
{
EventID MyEventID = new EventID(SortedByStartArrayOfBusyTimeLine[i].TimeLineID);
string ParentCalendarEventID = MyEventID.getLevelID(0);
if ((AllEventDictionary[ParentCalendarEventID].Start < MyRange.Start) && (AllEventDictionary[ParentCalendarEventID].End > MyRange.End))//checks if Calendar Event Starts starts before range and ends after range
{
MyArrayOfBeforeAndEndsAfterBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID].getSubEvent(MyEventID));
MyArrayCalendarEventOfBeforeAndEndsAfterBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID]);
}
if ((AllEventDictionary[ParentCalendarEventID].Start < MyRange.Start) && (AllEventDictionary[ParentCalendarEventID].End <= MyRange.End))//checks if Calendar Event Starts starts before range and ends within range
{
MyArrayOfBeforeAndEndsBeforeBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID].getSubEvent(MyEventID));
MyArrayCalendarEventOfBeforeAndEndsBeforeBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID]);
}
if ((AllEventDictionary[ParentCalendarEventID].Start >= MyRange.Start) && (AllEventDictionary[ParentCalendarEventID].End <= MyRange.End))//checks if Calendar Event Starts within range and ends within range
{
MyArrayOfStartsAndEndsBeforeBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID].getSubEvent(MyEventID));
MyArrayCalendarEventOfStartsAndEndsBeforeBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID]);
}
if ((AllEventDictionary[ParentCalendarEventID].Start >= MyRange.Start) && (AllEventDictionary[ParentCalendarEventID].End > MyRange.End))//checks if Calendar Event Starts within range and ends after range
{
MyArrayOfStartsAfterAndEndsAfterBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID].getSubEvent(MyEventID));
MyArrayCalendarEventOfStartsAfterAndEndsAfterBusyTimelines.Add((AllEventDictionary[ParentCalendarEventID]));
}
}
ArrayOfDifferentVaryingSubEventsCategories[0] = MyArrayOfBeforeAndEndsAfterBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[1] = MyArrayOfBeforeAndEndsBeforeBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[2] = MyArrayOfStartsAfterAndEndsAfterBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[3] = MyArrayOfStartsAndEndsBeforeBusyTimelines;
ArrayCalendarEventOfDifferentVaryingSubEventsCategories[0] = MyArrayCalendarEventOfBeforeAndEndsAfterBusyTimelines;
ArrayCalendarEventOfDifferentVaryingSubEventsCategories[1] = MyArrayCalendarEventOfBeforeAndEndsBeforeBusyTimelines;
ArrayCalendarEventOfDifferentVaryingSubEventsCategories[2] = MyArrayCalendarEventOfStartsAfterAndEndsAfterBusyTimelines;
ArrayCalendarEventOfDifferentVaryingSubEventsCategories[3] = MyArrayCalendarEventOfStartsAndEndsBeforeBusyTimelines;
return ArrayOfDifferentVaryingSubEventsCategories;
}
string BuildStringIndexForMatch(BusyTimeLine PrecedingTimeLineEvent, BusyTimeLine NextTimeLineEvent)
{
EventID MyEventID = new EventID(PrecedingTimeLineEvent.TimeLineID);
int PrecedingCalendarEventID = Convert.ToInt16(MyEventID.getLevelID(0));
int NextCalendarEventID = Convert.ToInt16(new EventID(NextTimeLineEvent.TimeLineID).getLevelID(0));
if (PrecedingCalendarEventID == NextCalendarEventID)
{
return "sameElement";
}
else
{
if (PrecedingCalendarEventID < NextCalendarEventID)
{
return PrecedingCalendarEventID + "_" + NextCalendarEventID;
}
return NextCalendarEventID + "_" + PrecedingCalendarEventID;
}
}
BusyTimeLine[] GetBusySlotPerCalendarEvent(CalendarEvent MyEvent)
{
int i = 0;
List<BusyTimeLine> MyTotalSubEventBusySlots = new List<BusyTimeLine>(0);
BusyTimeLine[] ArrayOfBusySlotsInRepeat = new BusyTimeLine[0];
DateTime LastDeadline = Now.AddHours(1);
if (MyEvent.RepetitionStatus)
{
ArrayOfBusySlotsInRepeat = GetBusySlotsPerRepeat(MyEvent.Repeat);
}
/*for (;i<MyEvent.AllEvents.Length;i++)
{
{*/
foreach (SubCalendarEvent MySubCalendarEvent in MyEvent.AllEvents)
{
if (!MyEvent.RepetitionStatus)
{ MyTotalSubEventBusySlots.Add(MySubCalendarEvent.ActiveSlot); }
}
//MyTotalSubEventBusySlots.Add(MyEvent.AllEvents[i].ActiveSlot);
/*}
}*/
//BusyTimeLine[] ConcatenatSumOfAllBusySlots = new BusyTimeLine[ArrayOfBusySlotsInRepeat.Length + MyTotalSubEventBusySlots.Count];
/*
i = 0;
for (; i < ArrayOfBusySlotsInRepeat.Length; i++)
{
ConcatenatSumOfAllBusySlots[i] = ArrayOfBusySlotsInRepeat[i];
}
i = ArrayOfBusySlotsInRepeat.Length;
int LengthOfConcatenatSumOfAllBusySlots = ConcatenatSumOfAllBusySlots.Length;
int j = 0;
j = i;
for (; j < LengthOfConcatenatSumOfAllBusySlots;)
{
ConcatenatSumOfAllBusySlots[j] = MyTotalSubEventBusySlots[i];
i++;
j++;
}*/
var Holder = MyTotalSubEventBusySlots.Concat(ArrayOfBusySlotsInRepeat);
BusyTimeLine[] ConcatenatSumOfAllBusySlots = Holder.ToArray();
//ArrayOfBusySlotsInRepeat.CopyTo(ConcatenatSumOfAllBusySlots, 0);
//MyTotalSubEventBusySlots.CopyTo(ConcatenatSumOfAllBusySlots, ConcatenatSumOfAllBusySlots.Length);
//ArrayOfBusySlotsInRepeat.CopyTo(ConcatenatSumOfAllBusySlots, 0);
return ConcatenatSumOfAllBusySlots;
}
public CalendarEvent EvaluateTotalTimeLineAndAssignValidTimeSpotsWithReferenceTimeLine(CalendarEvent MyEvent, TimeLine ReferenceTimeLine)
{
BusyTimeLine[] AllOccupiedSlot = ReferenceTimeLine.OccupiedSlots; //CompleteSchedule.OccupiedSlots;
TimeSpan TotalActiveDuration = new TimeSpan();
TimeLine[] TimeLineArrayWithSubEventsAssigned = new TimeLine[MyEvent.AllEvents.Length];
SubCalendarEvent TempSubEvent = new SubCalendarEvent();
BusyTimeLine MyTempBusyTimerLine = new BusyTimeLine();
TimeLine[] FreeSpotsAvailableWithinValidTimeline = getAllFreeSpots_NoCompleteSchedule(ReferenceTimeLine);
FreeSpotsAvailableWithinValidTimeline = getOnlyPertinentTimeFrame(FreeSpotsAvailableWithinValidTimeline, ReferenceTimeLine).ToArray();
int i = 0;
TimeSpan TotalFreeTimeAvailable = new TimeSpan();
if (MyEvent.Rigid)
{
TempSubEvent = new SubCalendarEvent(MyEvent.ActiveDuration, MyEvent.Start, MyEvent.End, MyEvent.Preparation, MyEvent.ID,MyEvent.Rigid, MyEvent.myLocation, MyEvent.RangeTimeLine);//fix rigid bug
MyTempBusyTimerLine = new BusyTimeLine(TempSubEvent.ID, TempSubEvent.Start, TempSubEvent.End);
TempSubEvent = new SubCalendarEvent(TempSubEvent.ID, TempSubEvent.Start, TempSubEvent.End, MyTempBusyTimerLine, MyEvent.Rigid, MyEvent.myLocation, MyEvent.RangeTimeLine);
MyEvent.AllEvents[0] = TempSubEvent;
}
else
{
for (i = 0; i < FreeSpotsAvailableWithinValidTimeline.Length; i++)
{
TotalFreeTimeAvailable += FreeSpotsAvailableWithinValidTimeline[i].TimelineSpan;
}
if (TotalFreeTimeAvailable >= MyEvent.ActiveDuration)
{
TimeLineArrayWithSubEventsAssigned = SplitFreeSpotsInToSubEventTimeSlots(FreeSpotsAvailableWithinValidTimeline, MyEvent.AllEvents.Length, MyEvent.ActiveDuration);
if (TimeLineArrayWithSubEventsAssigned == null)
{
BusyTimeLine[] CompleteScheduleOccupiedSlots = ReferenceTimeLine.OccupiedSlots;
KeyValuePair<CalendarEvent, TimeLine> TimeLineAndCalendarUpdated = ReArrangeTimeLineWithinWithinCalendaEventRange(MyEvent,null);
CalendarEvent MyCalendarEventUpdated = TimeLineAndCalendarUpdated.Key;
CompleteSchedule.OccupiedSlots = TimeLineAndCalendarUpdated.Value.OccupiedSlots;//hack need to review architecture to avoid this assignment
if (MyCalendarEventUpdated != null)
{
foreach (BusyTimeLine MyBusyTimeLine in CompleteSchedule.OccupiedSlots)
{
string ParentID = (new EventID(MyBusyTimeLine.TimeLineID)).getLevelID(0);
SubCalendarEvent[] MyArrayOfSubCalendarEvents = AllEventDictionary[ParentID].AllEvents;
for (i = 0; i < MyArrayOfSubCalendarEvents.Length; i++)
{
if (MyArrayOfSubCalendarEvents[i].ID == MyBusyTimeLine.TimeLineID)
{
MyArrayOfSubCalendarEvents[i] = new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine, MyArrayOfSubCalendarEvents[i].Rigid, MyArrayOfSubCalendarEvents[i].myLocation, MyArrayOfSubCalendarEvents[i].getCalendarEventRange);
}
}
}
return MyCalendarEventUpdated;
}
}
}
else
{
//MessageBox.Show("Sorry, the total free time available during activiy limits is less than your active duration!!!");
return new CalendarEvent(new CustomErrors(true, "There isnt enough timee in for the time space"));
}
if (TimeLineArrayWithSubEventsAssigned.Length < MyEvent.AllEvents.Length)// This means the assigned time per subevent spots won't be sufficient for the subevents available to the calendar event
{
return null;
}
i = 0;
for (; i < MyEvent.AllEvents.Length; i++)
{
TempSubEvent = new SubCalendarEvent(TimeLineArrayWithSubEventsAssigned[i].TimelineSpan, TimeLineArrayWithSubEventsAssigned[i].Start.Add(-MyEvent.Preparation), TimeLineArrayWithSubEventsAssigned[i].End, MyEvent.Preparation, MyEvent.ID, MyEvent.Rigid, MyEvent.AllEvents[i].myLocation, MyEvent.RangeTimeLine);
MyTempBusyTimerLine = new BusyTimeLine(TempSubEvent.ID, TimeLineArrayWithSubEventsAssigned[i].Start, TimeLineArrayWithSubEventsAssigned[i].End);
TempSubEvent = new SubCalendarEvent(TempSubEvent.ID, TimeLineArrayWithSubEventsAssigned[i].Start.Add(-MyEvent.Preparation), TimeLineArrayWithSubEventsAssigned[i].End, MyTempBusyTimerLine, MyEvent.Rigid, MyEvent.AllEvents[i].myLocation, MyEvent.RangeTimeLine);
MyEvent.AllEvents[i] = TempSubEvent;
}
}
if (MyEvent.RepetitionStatus)
{
for (i = 0; i < MyEvent.Repeat.RecurringCalendarEvents.Length; i++)
{
MyEvent.Repeat.RecurringCalendarEvents[i] = EvaluateTotalTimeLineAndAssignValidTimeSpots(MyEvent.Repeat.RecurringCalendarEvents[i]);
}
}
return MyEvent;
}
//This returns An array of a List of SubCalendarEvents. The function goes through each of the BUsytimeline Events and verifies if its parent calendar Event has a start Time that is eiter earlier than range, within range or start and ends within the range
List<BusyTimeLine>[] CategorizeTimeLine_noEventSchedule(TimeLine MyRange, BusyTimeLine[] SortedByStartArrayOfBusyTimeLine)
{
List<BusyTimeLine>[] ArrayOfDifferentVaryingSubEventsCategories = new List<BusyTimeLine>[4];
List<BusyTimeLine> MyArrayOfBeforeAndEndsAfterBusyTimelines = new List<BusyTimeLine>(0);
List<BusyTimeLine> MyArrayOfBeforeAndEndsBeforeBusyTimelines = new List<BusyTimeLine>(0);
List<BusyTimeLine> MyArrayOfStartsAfterAndEndsAfterBusyTimelines = new List<BusyTimeLine>(0);
List<BusyTimeLine> MyArrayOfStartsAndEndsBeforeBusyTimelines = new List<BusyTimeLine>(0);
int i = 0;
for (; i < SortedByStartArrayOfBusyTimeLine.Length; i++)
{
EventID MyEventID = new EventID(SortedByStartArrayOfBusyTimeLine[i].TimeLineID);
string ParentCalendarEventID = MyEventID.getLevelID(0);
if ((MyRange.Start < SortedByStartArrayOfBusyTimeLine[i].Start) && (MyRange.End > SortedByStartArrayOfBusyTimeLine[i].End))//checks if Calendar Event Starts starts before range and ends after range
{
MyArrayOfStartsAndEndsBeforeBusyTimelines.Add(SortedByStartArrayOfBusyTimeLine[i]);
}
if ((MyRange.Start < SortedByStartArrayOfBusyTimeLine[i].Start) && (MyRange.End <= SortedByStartArrayOfBusyTimeLine[i].End))//checks if Calendar Event Starts starts before range and ends within range
{
MyArrayOfStartsAfterAndEndsAfterBusyTimelines.Add(SortedByStartArrayOfBusyTimeLine[i]);
}
if ((MyRange.Start >= SortedByStartArrayOfBusyTimeLine[i].Start) && (MyRange.End > SortedByStartArrayOfBusyTimeLine[i].End))//checks if Calendar Event Starts within range and ends after range
{
MyArrayOfBeforeAndEndsBeforeBusyTimelines.Add(SortedByStartArrayOfBusyTimeLine[i]);
}
if ((MyRange.Start >= SortedByStartArrayOfBusyTimeLine[i].Start) && (MyRange.End <= SortedByStartArrayOfBusyTimeLine[i].End))//checks if Calendar Event Starts within range and ends within range
{
MyArrayOfBeforeAndEndsAfterBusyTimelines.Add(SortedByStartArrayOfBusyTimeLine[i]);
}
}
ArrayOfDifferentVaryingSubEventsCategories[0] = MyArrayOfBeforeAndEndsAfterBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[1] = MyArrayOfBeforeAndEndsBeforeBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[2] = MyArrayOfStartsAfterAndEndsAfterBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[3] = MyArrayOfStartsAndEndsBeforeBusyTimelines;
return ArrayOfDifferentVaryingSubEventsCategories;
}
//yet to debug
public BusyTimeLine getLatestEndBusyTime(List<BusyTimeLine> List_BusyTimekLine, BusyTimeLine LatestEndBusyTime)
{
foreach(BusyTimeLine MyBusyTimeLine in List_BusyTimekLine)
{
if (MyBusyTimeLine.End > LatestEndBusyTime.End)
{
LatestEndBusyTime = MyBusyTimeLine;
}
}
return LatestEndBusyTime;
}
//further update will be to check if it interferes
public void AddBusySlots(BusyTimeLine MyBusySlot)
{
List<BusyTimeLine> MyListOfActiveSlots = ActiveTimeSlots.ToList();//;
MyListOfActiveSlots.Add(MyBusySlot);
ActiveTimeSlots = MyListOfActiveSlots.ToArray();
}
//further update will be to check if it interferes
public void AddBusySlots(BusyTimeLine[] MyBusySlot)
{
var MyNewArray = ActiveTimeSlots.Concat(MyBusySlot);
ActiveTimeSlots = MyNewArray.ToArray();
}
// this looks at the timeline of the calendar event and then tries to rearrange all subevents within the range to suit final output. Such that there will be sufficient time space for each subevent
KeyValuePair<CalendarEvent, TimeLine> ReArrangeTimeLineWithinWithinCalendaEventRange(CalendarEvent MyCalendarEvent)
{
/*
Name{: Jerome Biotidara
* this function is responsible for making sure there is some dynamic allotment of time to the subeevents. It takes a calendarevent, checks the alloted time frame and tries to move subevents within the time frame to satisfy the final goal.
*/
SubCalendarEvent[] ArrayOfInterferringSubEvents = getInterferringSubEvents(MyCalendarEvent);//It gets all the subevents within the time frame
ArrayOfInterferringSubEvents = SortSubCalendarEvents(ArrayOfInterferringSubEvents.ToList(), false).ToArray();
BusyTimeLine[] InterferringDateTime = new BusyTimeLine[ArrayOfInterferringSubEvents.Length];
Dictionary<CalendarEvent, List<SubCalendarEvent>> DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = new Dictionary<CalendarEvent, List<SubCalendarEvent>>();
int i=0;
for (; i < InterferringDateTime.Length; i++)//for loop populates InteferringDateTIme so that it can be populated
{
InterferringDateTime[i] = ArrayOfInterferringSubEvents[i].ActiveSlot;
}
InterferringDateTime = SortBusyTimeline(InterferringDateTime.ToList(), false).ToArray();
List<BusyTimeLine>[] MyEdgeElements = getEdgeElements(MyCalendarEvent.EventTimeLine, InterferringDateTime);
List<CalendarEvent>[] CalendarEventsTimeCategories = CategorizeCalendarEventTimeLine(MyCalendarEvent.EventTimeLine, InterferringDateTime);
List<SubCalendarEvent>[]SubEventsTimeCategories= CategorizeSubEventsTimeLine(MyCalendarEvent.EventTimeLine, InterferringDateTime);
List<SubCalendarEvent> RigidSubCalendarEvents = new List<SubCalendarEvent>(0);
List<BusyTimeLine> RigidSubCalendarEventsBusyTimeLine = new List<BusyTimeLine>(0);
i = 0;
int j = 0;
for (; i < SubEventsTimeCategories.Length; i++)//loop detects the rigid subevents and populates RigidSubCalendarEvents list
{
j = 0;
for (; j < SubEventsTimeCategories[i].Count; j++)
{
if (SubEventsTimeCategories[i][j].Rigid)
{
RigidSubCalendarEvents.Add(SubEventsTimeCategories[i][j]);
RigidSubCalendarEventsBusyTimeLine.Add(SubEventsTimeCategories[i][j].ActiveSlot);
}
}
}
ArrayOfInterferringSubEvents = Utility.NotInList(ArrayOfInterferringSubEvents.ToList(), RigidSubCalendarEvents).ToArray();
List<CalendarEvent> EndingBeforeDeadlineList = CalendarEventsTimeCategories[1].Concat(CalendarEventsTimeCategories[3]).ToList();
CalendarEvent[] EndingBeforeDeadlineArray = EndingBeforeDeadlineList.ToArray();
Array.Sort(EndingBeforeDeadlineArray, CalendarEvent.CompareByEndDate);
EndingBeforeDeadlineList = EndingBeforeDeadlineArray.ToList();
//List<CalendarEvent>[]SubEventsTimeCategories= CategorizeSubEventsTimeLine
/*
* SubEventsTimeCategories has 4 list of containing lists.
* 1st is a List with Elements Starting before The Mycalendaervent timeline and ends after the busytimeline
* 2nd is a list with elements starting before the mycalendarvent timeline but ending before the myevent timeline
* 3rd is a list with elements starting after the Mycalendar event start time but ending after the Myevent timeline
* 4th is a list with elements starting after the MyCalendar event start time and ends before the Myevent timeline
* */
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = generateDictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents(ArrayOfInterferringSubEvents.ToList());
if (MyCalendarEvent.RepetitionStatus == false)//generates random subevents for the calendar event
{
SubCalendarEvent[] TempSubCalendarEventsForMyCalendarEvent = new SubCalendarEvent[MyCalendarEvent.NumberOfSplit];
//int i;
for (i = 0; i < TempSubCalendarEventsForMyCalendarEvent.Length; i++)//populates the subevents for the calendar event
{
TimeSpan MyActiveTimeSpanPerSplit = new TimeSpan((long)((MyCalendarEvent.ActiveDuration.TotalSeconds / MyCalendarEvent.NumberOfSplit) * 10000000));
TempSubCalendarEventsForMyCalendarEvent[i] = new SubCalendarEvent(MyActiveTimeSpanPerSplit, MyCalendarEvent.Start, (MyCalendarEvent.Start + MyActiveTimeSpanPerSplit), new TimeSpan(), MyCalendarEvent.ID, MyCalendarEvent.EventTimeLine);
TempSubCalendarEventsForMyCalendarEvent[i] = new SubCalendarEvent(TempSubCalendarEventsForMyCalendarEvent[i].ID, TempSubCalendarEventsForMyCalendarEvent[i].Start, TempSubCalendarEventsForMyCalendarEvent[i].End, new BusyTimeLine(TempSubCalendarEventsForMyCalendarEvent[i].ID, TempSubCalendarEventsForMyCalendarEvent[i].Start, TempSubCalendarEventsForMyCalendarEvent[i].End), MyCalendarEvent.EventTimeLine);
MyCalendarEvent.AllEvents[i] = TempSubCalendarEventsForMyCalendarEvent[i];
}
}
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(MyCalendarEvent, MyCalendarEvent.AllEvents.ToList());
List<CalendarEvent> SortedInterFerringCalendarEvents_Deadline = DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Keys.ToList();
SortedInterFerringCalendarEvents_Deadline = SortedInterFerringCalendarEvents_Deadline.OrderBy(obj => obj.End).ToList();
//SortCalendarEvent(DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Keys.ToList(),false);
//SortedInterFerringCalendarEvents.Add(MyCalendarEvent);
//SubEventsTimeCategories[]
TimeLine ReferenceTimeLine = new TimeLine(MyCalendarEvent.Start,MyCalendarEvent.End);
ReferenceTimeLine.AddBusySlots(RigidSubCalendarEventsBusyTimeLine.ToArray());//Adds all the rigid elements
TimeLine[] ArrayOfFreeSpots = getOnlyPertinentTimeFrame(getAllFreeSpots_NoCompleteSchedule(ReferenceTimeLine), ReferenceTimeLine).ToArray();
ArrayOfFreeSpots = getOnlyPertinentTimeFrame(ArrayOfFreeSpots, ReferenceTimeLine).ToArray();
//CompleteSchedule.MergeTimeLines(ReferenceTimeLine);//further check that mergre doesnt duplicate timeLines
//NotInList(SortedInterFerringCalendarEve,
Dictionary<TimeLine, List<CalendarEvent>> DictTimeLineAndListOfCalendarevent = new System.Collections.Generic.Dictionary<TimeLine, System.Collections.Generic.List<CalendarEvent>>();
/*foreach (CalendarEvent MyCalendarEvent0 in EndingBeforeDeadlineArray)//Foreach statement pins interferring subevents to start of timeline//Disabling pintostart to see if Buildsnugpossibility can fix this
{
foreach (TimeLine MyTimeLine in ArrayOfFreeSpots)
{
TimeLine TimeLineAfterPinToStart=MyCalendarEvent0.PinSubEventsToStart(MyTimeLine, DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[MyCalendarEvent0]);
if (TimeLineAfterPinToStart != null)
{
ReferenceTimeLine.MergeTimeLines(TimeLineAfterPinToStart);
break;
}
//CalendarEvent[] PertinentCalendarEvents = getPertinentCalendarEvents(EndingBeforeDeadlineArray, MyTimeLine);
//Array.Sort(PertinentCalendarEvents, CalendarEvent.CompareByEndDate);
//DictTimeLineAndListOfCalendarevent.Add(MyTimeLine, PertinentCalendarEvents.ToList());
}
ArrayOfFreeSpots = getOnlyPertinentTimeFrame(getAllFreeSpots_NoCompleteSchedule(ReferenceTimeLine),ReferenceTimeLine).ToArray();
}*/
/*foreach (TimeLine MyTimeLine in ArrayOfFreeSpots)
{
TimeLine TimeLineAfterPinToStart = MyCalendarEvent.PinSubEventsToStart(MyTimeLine, TempSubCalendarEventsForMyCalendarEvent.ToList());
if (TimeLineAfterPinToStart != null)
{
ReferenceTimeLine.MergeTimeLines(TimeLineAfterPinToStart);
break;
}
}*/
/*BusyTimeLine[] BeforeSnugListFunctionalityImplemented=CompleteSchedule.OccupiedSlots;//****IMPORTANT DO NOT DELETE UNLESS YOU UNDERSTAND WHY YOU WANT TO DELETE COMMENT SECTIONN
CompleteSchedule.OccupiedSlots=ReferenceTimeLine.OccupiedSlots;
MyCalendarEvent=EvaluateTotalTimeLineAndAssignValidTimeSpots(MyCalendarEvent);
if (MyCalendarEvent != null)
{
return MyCalendarEvent;
}*/
//DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(MyCalendarEvent, MyCalendarEvent.AllEvents.ToList());
//RETURN HERE JEROME
List<List<List<SubCalendarEvent>>> SnugListOfPossibleSubCalendarEventsClumps = BuildAllPossibleSnugLists(SortedInterFerringCalendarEvents_Deadline, MyCalendarEvent, DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents, CalendarEventsTimeCategories, ReferenceTimeLine);
//Remember Jerome, I need to implement a functionality that permutates through the various options of pin to start option. So take for example two different event timeline that are pertinent to a free spot however one has a dead line preceeding the other, there will be a pin to start for two scenarios, one for each calendar event in which either of them gets pinned first.
return EvaluateEachSnugPossibiliyOfSnugPossibility(SnugListOfPossibleSubCalendarEventsClumps, ReferenceTimeLine,MyCalendarEvent);
;//this will not be the final output. I'll need some class that stores the current output of both rearrange busytimelines and deleted timelines
}
SubCalendarEvent[] ReadSubSchedulesFromXMLNode(XmlNode MyXmlNode,CalendarEvent MyParent)
{
SubCalendarEvent[] MyArrayOfNodes = new SubCalendarEvent[MyXmlNode.ChildNodes.Count];
string ID = "";
DateTime Start = new DateTime();
DateTime End = new DateTime();
TimeSpan SubScheduleDuration=new TimeSpan();
TimeSpan PrepTime=new TimeSpan();
BusyTimeLine BusySlot=new BusyTimeLine();
for (int i=0;i<MyXmlNode.ChildNodes.Count;i++)
{
BusyTimeLine SubEventActivePeriod = new BusyTimeLine(MyXmlNode.ChildNodes[i].SelectSingleNode("ID").InnerText,stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveStartTime").InnerText),stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveEndTime").InnerText));
ID=MyXmlNode.ChildNodes[i].SelectSingleNode("ID").InnerText;
Start=stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveStartTime").InnerText);
End=stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveEndTime").InnerText);
BusySlot=new BusyTimeLine(ID,Start,End);
PrepTime=new TimeSpan(ConvertToMinutes(MyXmlNode.ChildNodes[i].SelectSingleNode("PrepTime").InnerText)*60*10000000);
//stringToDateTime();
Start=stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("StartTime").InnerText);
End=stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("EndTime").InnerText);
MyArrayOfNodes[i] = new SubCalendarEvent(ID, BusySlot, Start, End, PrepTime, MyParent.ID, MyParent.Rigid, MyParent.EventTimeLine);
MyArrayOfNodes[i].ThirdPartyID = MyXmlNode.ChildNodes[i].SelectSingleNode("ThirdPartyID").InnerText;//this is a hack to just update the Third partyID
}
return MyArrayOfNodes;
}
List<BusyTimeLine>[] getEdgeElements(TimeLine MyRangeOfTimeLine, BusyTimeLine[] ArrayOfTInterferringime)
{
List<BusyTimeLine> ListOfEdgeElements = new List<BusyTimeLine>();
List<BusyTimeLine> StartEdge = new List<BusyTimeLine>();
List<BusyTimeLine> EndEdge = new List<BusyTimeLine>();
int i=0;
for (; i < ArrayOfTInterferringime.Length; i++)
{
if (!MyRangeOfTimeLine.IsTimeLineWithin(ArrayOfTInterferringime[i]))
{
ListOfEdgeElements.Add(ArrayOfTInterferringime[i]);
}
}
i = 0;
for (; i < ListOfEdgeElements.Count; i++)
{
if (ListOfEdgeElements[i].Start < MyRangeOfTimeLine.Start)
{
StartEdge.Add(ListOfEdgeElements[i]);
}
else
{
EndEdge.Add(ListOfEdgeElements[i]);
}
}
List<BusyTimeLine>[] StartAndEndEdgeList = new List<BusyTimeLine>[2];
StartAndEndEdgeList[0] = StartEdge;
StartAndEndEdgeList[1] = EndEdge;
return StartAndEndEdgeList;
}
public CalendarEvent EvaluateTotalTimeLineAndAssignValidTimeSpots(CalendarEvent MyEvent)
{
int i = 0;
if (MyEvent.RepetitionStatus)
{
for (i = 0; i < MyEvent.Repeat.RecurringCalendarEvents.Length; i++)
{
if (i == 3)
{
//MessageBox.Show("Scroll through Jerome");
;
}
MyEvent.Repeat.RecurringCalendarEvents[i] = EvaluateTotalTimeLineAndAssignValidTimeSpots(MyEvent.Repeat.RecurringCalendarEvents[i]);
}
return MyEvent;
}
BusyTimeLine [] AllOccupiedSlot= CompleteSchedule.OccupiedSlots;
TimeSpan TotalActiveDuration=new TimeSpan();
TimeLine[] TimeLineArrayWithSubEventsAssigned = new TimeLine[MyEvent.AllEvents.Length];
SubCalendarEvent TempSubEvent=new SubCalendarEvent();
BusyTimeLine MyTempBusyTimerLine=new BusyTimeLine();
List<TimeLine> FreeSpotsAvailableWithinValidTimeline= getAllFreeSpots(new TimeLine(MyEvent.Start,MyEvent.End)).ToList();
FreeSpotsAvailableWithinValidTimeline = CheckTimeLineListForEncompassingTimeLine(FreeSpotsAvailableWithinValidTimeline, MyEvent.EventTimeLine);
FreeSpotsAvailableWithinValidTimeline = getOnlyPertinentTimeFrame(FreeSpotsAvailableWithinValidTimeline.ToArray(), new TimeLine(MyEvent.Start, MyEvent.End));
i = 0;
TimeSpan TotalFreeTimeAvailable=new TimeSpan();
if (MyEvent.Rigid)
{
bool []StatusOfClash=CheckIfPotentialSubEventClashesWithAnyOtherSubEvents(MyEvent, CompleteSchedule);
if (StatusOfClash[0] && StatusOfClash[1])
{
//MessageBox.Show("Are you sure?","Confirm", MessageBoxButtons.YesNo, MessageBoxImage.Question)
if (!(((WinForms::DialogResult)MessageBox.Show("Are you sure", "Confirm", MessageBoxButton.YesNo)) == WinForms::DialogResult.Yes))
{
return new CalendarEvent();
}
}
TempSubEvent = new SubCalendarEvent(MyEvent.ActiveDuration, MyEvent.Start, MyEvent.End, MyEvent.Preparation, MyEvent.ID, MyEvent.EventTimeLine);
MyTempBusyTimerLine = new BusyTimeLine(TempSubEvent.ID, TempSubEvent.Start, TempSubEvent.End);
TempSubEvent = new SubCalendarEvent(TempSubEvent.ID, TempSubEvent.Start, TempSubEvent.End, MyTempBusyTimerLine, MyEvent.Rigid, MyEvent.EventTimeLine);
MyEvent.AllEvents[0] = TempSubEvent;
}
else
{
for (i = 0; i < FreeSpotsAvailableWithinValidTimeline.Count; i++)
{
TotalFreeTimeAvailable += FreeSpotsAvailableWithinValidTimeline[i].TimelineSpan;
}
if (TotalFreeTimeAvailable >= MyEvent.ActiveDuration)
{
TimeLineArrayWithSubEventsAssigned = SplitFreeSpotsInToSubEventTimeSlots(FreeSpotsAvailableWithinValidTimeline.ToArray(), MyEvent.AllEvents.Length, MyEvent.ActiveDuration);
if (TimeLineArrayWithSubEventsAssigned == null)
{
BusyTimeLine[] CompleteScheduleOccupiedSlots = CompleteSchedule.OccupiedSlots;
KeyValuePair<CalendarEvent, TimeLine> TimeLineAndCalendarUpdated = ReArrangeTimeLineWithinWithinCalendaEventRange(MyEvent);
CalendarEvent MyCalendarEventUpdated = TimeLineAndCalendarUpdated.Key;
//CompleteSchedule.OccupiedSlots = TimeLineAndCalendarUpdated.Value.OccupiedSlots;//hack need to review architecture to avoid this assignment
if (MyCalendarEventUpdated != null)
{
string MyEventParentID = (new EventID(MyEvent.ID)).getLevelID(0);
foreach (BusyTimeLine MyBusyTimeLine in TimeLineAndCalendarUpdated.Value.OccupiedSlots)
{
string ParentID = (new EventID(MyBusyTimeLine.TimeLineID)).getLevelID(0);
if (ParentID != MyEventParentID)
{
SubCalendarEvent[] MyArrayOfSubCalendarEvents;
if (AllEventDictionary[ParentID].RepetitionStatus)
{
bool Verified = AllEventDictionary[ParentID].updateSubEvent(new EventID(MyBusyTimeLine.TimeLineID), new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine ));
}
else
{
MyArrayOfSubCalendarEvents = AllEventDictionary[ParentID].AllEvents;
for (i = 0; i < MyArrayOfSubCalendarEvents.Length; i++)
{
if (MyArrayOfSubCalendarEvents[i].ID == MyBusyTimeLine.TimeLineID)
{
MyArrayOfSubCalendarEvents[i] = new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine, MyArrayOfSubCalendarEvents[i].Rigid, AllEventDictionary[ParentID].EventTimeLine);
}
}
}
}
}
/*if (MyCalendarEventUpdated.RepetitionStatus)
{
for (i = 0; i < MyEvent.Repeat.RecurringCalendarEvents.Length; i++)
{
MyCalendarEventUpdated.Repeat.RecurringCalendarEvents[i] = EvaluateTotalTimeLineAndAssignValidTimeSpots(MyEvent.Repeat.RecurringCalendarEvents[i]);
}
}*/
return MyCalendarEventUpdated;
}
}
}
else
{
MessageBox.Show("Sorry, the total free time available during activiy limits is less than your active duration!!!");
List<CalendarEvent> ListOfCalendarEventsWithLatterDeadlines = new System.Collections.Generic.List<CalendarEvent>();
return new CalendarEvent();
}
if (TimeLineArrayWithSubEventsAssigned.Length < MyEvent.AllEvents.Length)// This means the assigned time per subevent spots won't be sufficient for the subevents available to the calendar event
{
return null;
}
i = 0;
for (; i < MyEvent.AllEvents.Length; i++)
{
TempSubEvent = new SubCalendarEvent(TimeLineArrayWithSubEventsAssigned[i].TimelineSpan, TimeLineArrayWithSubEventsAssigned[i].Start, TimeLineArrayWithSubEventsAssigned[i].End, MyEvent.Preparation, MyEvent.ID,MyEvent.Rigid,MyEvent.EventTimeLine);
MyTempBusyTimerLine = new BusyTimeLine(TempSubEvent.ID, TimeLineArrayWithSubEventsAssigned[i].Start, TimeLineArrayWithSubEventsAssigned[i].End);
TempSubEvent = new SubCalendarEvent(TempSubEvent.ID, TimeLineArrayWithSubEventsAssigned[i].Start.Add(-MyEvent.Preparation), TimeLineArrayWithSubEventsAssigned[i].End, MyTempBusyTimerLine, MyEvent.Rigid,MyEvent.EventTimeLine);
MyEvent.AllEvents[i] = TempSubEvent;
}
}
return MyEvent;
}
/*
public static bool operator ==(SubCalendarEvent arg1, SubCalendarEvent arg2)
{
return arg1.ID == arg2.ID;
}
public static bool operator !=(SubCalendarEvent arg1, SubCalendarEvent arg2)
{
return arg1.ID != arg2.ID;
}
*/
public override void ReassignTime(DateTime StartTime, DateTime EndTime)
{
EndDateTime = (EndTime);
StartDateTime = StartTime;
BusyFrame = new BusyTimeLine(SubEventID.ToString(), StartTime, EndTime);
}
SubCalendarEvent[] ReadSubSchedulesFromXMLNode(XmlNode MyXmlNode, CalendarEvent MyParent)
{
SubCalendarEvent[] MyArrayOfNodes = new SubCalendarEvent[MyXmlNode.ChildNodes.Count];
string ID = "";
DateTime Start = new DateTime();
DateTime End = new DateTime();
TimeSpan SubScheduleDuration = new TimeSpan();
TimeSpan PrepTime = new TimeSpan();
BusyTimeLine BusySlot = new BusyTimeLine();
bool Enabled;
for (int i = 0; i < MyXmlNode.ChildNodes.Count; i++)
{
BusyTimeLine SubEventActivePeriod = new BusyTimeLine(MyXmlNode.ChildNodes[i].SelectSingleNode("ID").InnerText, stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveStartTime").InnerText), stringToDateTime(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveEndTime").InnerText));
ID = MyXmlNode.ChildNodes[i].SelectSingleNode("ID").InnerText;
Start = DateTime.Parse(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveStartTime").InnerText);
End = DateTime.Parse(MyXmlNode.ChildNodes[i].SelectSingleNode("ActiveEndTime").InnerText);
BusySlot = new BusyTimeLine(ID, Start, End);
PrepTime = new TimeSpan(ConvertToMinutes(MyXmlNode.ChildNodes[i].SelectSingleNode("PrepTime").InnerText) * 60 * 10000000);
//stringToDateTime();
Start = DateTime.Parse(MyXmlNode.ChildNodes[i].SelectSingleNode("StartTime").InnerText);
End = DateTime.Parse(MyXmlNode.ChildNodes[i].SelectSingleNode("EndTime").InnerText);
Enabled=Convert.ToBoolean(MyXmlNode.ChildNodes[i].SelectSingleNode("Enabled").InnerText);
bool CompleteFlag = Convert.ToBoolean(MyXmlNode.ChildNodes[i].SelectSingleNode("Complete").InnerText);
Location var1 = getLocation(MyXmlNode.ChildNodes[i]);
MiscData noteData = getMiscData(MyXmlNode.ChildNodes[i]);
EventDisplay UiData = getDisplayUINode(MyXmlNode.ChildNodes[i]);
MyArrayOfNodes[i] = new SubCalendarEvent(ID, BusySlot, Start, End, PrepTime, MyParent.ID, MyParent.Rigid, Enabled, UiData, noteData, CompleteFlag, var1, MyParent.RangeTimeLine);
MyArrayOfNodes[i].ThirdPartyID = MyXmlNode.ChildNodes[i].SelectSingleNode("ThirdPartyID").InnerText;//this is a hack to just update the Third partyID
}
return MyArrayOfNodes;
}
public BusyTimeLine CreateCopy()
{
BusyTimeLine MyBusyTimlineCopy = new BusyTimeLine(this.TimeLineID,new DateTime(StartTime.Ticks),new DateTime(StartTime.Ticks));
return MyBusyTimlineCopy;
}
public void PopulateBusyTimeSlot(string MyEventID, BusyTimeLine[] myActiveTimeSlots)
{
ActiveTimeSlots = myActiveTimeSlots;
TimeLineEventID = MyEventID;
}
//This returns An array of a List of SubCalendarEvents. The function goes through each of the BUsytimeline Events and verifies if its parent calendar Event has a start Time that is eiter earlier than range, within range or start and ends within the range
List<SubCalendarEvent>[] CategorizeSubEventsTimeLine(TimeLine MyRange, BusyTimeLine[] SortedByStartArrayOfBusyTimeLine)
{
List<SubCalendarEvent>[] ArrayOfDifferentVaryingSubEventsCategories = new List<SubCalendarEvent>[4];
List<CalendarEvent>[] ArrayCalendarEventOfDifferentVaryingSubEventsCategories = new List<CalendarEvent>[4];
List<SubCalendarEvent> MyArrayOfBeforeAndEndsAfterBusyTimelines = new List<SubCalendarEvent>(0);
List<CalendarEvent> MyArrayCalendarEventOfBeforeAndEndsAfterBusyTimelines = new List<CalendarEvent>(0);
List<SubCalendarEvent> MyArrayOfBeforeAndEndsBeforeBusyTimelines = new List<SubCalendarEvent>(0);
List<CalendarEvent> MyArrayCalendarEventOfBeforeAndEndsBeforeBusyTimelines = new List<CalendarEvent>(0);
List<SubCalendarEvent> MyArrayOfStartsAfterAndEndsAfterBusyTimelines = new List<SubCalendarEvent>(0);
List<CalendarEvent> MyArrayCalendarEventOfStartsAfterAndEndsAfterBusyTimelines = new List<CalendarEvent>(0);
List<SubCalendarEvent> MyArrayOfStartsAndEndsBeforeBusyTimelines = new List<SubCalendarEvent>(0);
List<CalendarEvent> MyArrayCalendarEventOfStartsAndEndsBeforeBusyTimelines = new List<CalendarEvent>(0);
int i = 0;
for (; i < SortedByStartArrayOfBusyTimeLine.Length; i++)
{
EventID MyEventID= new EventID(SortedByStartArrayOfBusyTimeLine[i].TimeLineID);
string ParentCalendarEventID=MyEventID.getLevelID(0);
if ((AllEventDictionary[ParentCalendarEventID].Start < MyRange.Start) && (AllEventDictionary[ParentCalendarEventID].End > MyRange.End))//checks if Calendar Event Starts starts before range and ends after range
{
MyArrayOfBeforeAndEndsAfterBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID].getSubEvent(MyEventID));
MyArrayCalendarEventOfBeforeAndEndsAfterBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID]);
}
if ((AllEventDictionary[ParentCalendarEventID].Start < MyRange.Start) && (AllEventDictionary[ParentCalendarEventID].End <= MyRange.End))//checks if Calendar Event Starts starts before range and ends within range
{
MyArrayOfBeforeAndEndsBeforeBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID].getSubEvent(MyEventID));
MyArrayCalendarEventOfBeforeAndEndsBeforeBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID]);
}
if ((AllEventDictionary[ParentCalendarEventID].Start >= MyRange.Start) && (AllEventDictionary[ParentCalendarEventID].End <= MyRange.End))//checks if Calendar Event Starts within range and ends within range
{
MyArrayOfStartsAndEndsBeforeBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID].getSubEvent(MyEventID));
MyArrayCalendarEventOfStartsAndEndsBeforeBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID]);
}
if ((AllEventDictionary[ParentCalendarEventID].Start >= MyRange.Start) && (AllEventDictionary[ParentCalendarEventID].End > MyRange.End))//checks if Calendar Event Starts within range and ends after range
{
MyArrayOfStartsAfterAndEndsAfterBusyTimelines.Add(AllEventDictionary[ParentCalendarEventID].getSubEvent(MyEventID));
MyArrayCalendarEventOfStartsAfterAndEndsAfterBusyTimelines.Add((AllEventDictionary[ParentCalendarEventID]));
}
}
ArrayOfDifferentVaryingSubEventsCategories[0] = MyArrayOfBeforeAndEndsAfterBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[1] = MyArrayOfBeforeAndEndsBeforeBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[2] = MyArrayOfStartsAfterAndEndsAfterBusyTimelines;
ArrayOfDifferentVaryingSubEventsCategories[3] = MyArrayOfStartsAndEndsBeforeBusyTimelines;
ArrayCalendarEventOfDifferentVaryingSubEventsCategories[0] = MyArrayCalendarEventOfBeforeAndEndsAfterBusyTimelines;
ArrayCalendarEventOfDifferentVaryingSubEventsCategories[1] = MyArrayCalendarEventOfBeforeAndEndsBeforeBusyTimelines;
ArrayCalendarEventOfDifferentVaryingSubEventsCategories[2] = MyArrayCalendarEventOfStartsAfterAndEndsAfterBusyTimelines;
ArrayCalendarEventOfDifferentVaryingSubEventsCategories[3] = MyArrayCalendarEventOfStartsAndEndsBeforeBusyTimelines;
return ArrayOfDifferentVaryingSubEventsCategories;
}
public CalendarEvent EvaluateTotalTimeLineAndAssignValidTimeSpots(CalendarEvent MyEvent, List<CalendarEvent> NoneCOmmitedCalendarEvent =null)
{
int i = 0;
if (NoneCOmmitedCalendarEvent == null)
{
NoneCOmmitedCalendarEvent = new List<CalendarEvent>();
}
if (MyEvent.RepetitionStatus)
{
for (i = 0; i < MyEvent.Repeat.RecurringCalendarEvents.Length; i++)
{
MyEvent.Repeat.RecurringCalendarEvents[i] = EvaluateTotalTimeLineAndAssignValidTimeSpots(MyEvent.Repeat.RecurringCalendarEvents[i], NoneCOmmitedCalendarEvent);
NoneCOmmitedCalendarEvent.Add(MyEvent.Repeat.RecurringCalendarEvents[i]);
}
return MyEvent;
}
BusyTimeLine[] AllOccupiedSlot = CompleteSchedule.OccupiedSlots;
TimeSpan TotalActiveDuration = new TimeSpan();
TimeLine[] TimeLineArrayWithSubEventsAssigned = new TimeLine[MyEvent.AllEvents.Length];
SubCalendarEvent TempSubEvent = new SubCalendarEvent();
BusyTimeLine MyTempBusyTimerLine = new BusyTimeLine();
List<TimeLine> FreeSpotsAvailableWithinValidTimeline = getAllFreeSpots(new TimeLine(MyEvent.Start, MyEvent.End)).ToList();
FreeSpotsAvailableWithinValidTimeline = CheckTimeLineListForEncompassingTimeLine(FreeSpotsAvailableWithinValidTimeline, MyEvent.RangeTimeLine);
FreeSpotsAvailableWithinValidTimeline = getOnlyPertinentTimeFrame(FreeSpotsAvailableWithinValidTimeline.ToArray(), new TimeLine(MyEvent.Start, MyEvent.End));
i = 0;
TimeSpan TotalFreeTimeAvailable = new TimeSpan();
if (MyEvent.Rigid)
{
TempSubEvent = new SubCalendarEvent(MyEvent.ActiveDuration, MyEvent.Start, MyEvent.End, MyEvent.Preparation, MyEvent.ID,MyEvent.Rigid, MyEvent.myLocation, MyEvent.RangeTimeLine);
MyTempBusyTimerLine = new BusyTimeLine(TempSubEvent.ID, TempSubEvent.Start, TempSubEvent.End);
TempSubEvent = new SubCalendarEvent(TempSubEvent.ID, TempSubEvent.Start, TempSubEvent.End, MyTempBusyTimerLine, MyEvent.Rigid, MyEvent.myLocation, MyEvent.RangeTimeLine);
MyEvent.AllEvents[0] = TempSubEvent;
KeyValuePair<CalendarEvent, TimeLine> TimeLineAndCalendarUpdated = ReArrangeClashingEventsofRigid(MyEvent, NoneCOmmitedCalendarEvent.ToList());
CalendarEvent MyCalendarEventUpdated = TimeLineAndCalendarUpdated.Key;
if (MyCalendarEventUpdated != null && !MyCalendarEventUpdated.ErrorStatus)
{
string MyEventParentID = (new EventID(MyEvent.ID)).getLevelID(0);
foreach (BusyTimeLine MyBusyTimeLine in TimeLineAndCalendarUpdated.Value.OccupiedSlots)
{
string ParentID = (new EventID(MyBusyTimeLine.TimeLineID)).getLevelID(0);
if (ParentID != MyEventParentID)
{
SubCalendarEvent[] MyArrayOfSubCalendarEvents;
if (AllEventDictionary[ParentID].RepetitionStatus)
{
bool Verified = AllEventDictionary[ParentID].updateSubEvent(new EventID(MyBusyTimeLine.TimeLineID), new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine, AllEventDictionary[ParentID].Rigid, AllEventDictionary[ParentID].myLocation));
}
else
{
MyArrayOfSubCalendarEvents = AllEventDictionary[ParentID].AllEvents;
for (i = 0; i < MyArrayOfSubCalendarEvents.Length; i++)
{
if (MyArrayOfSubCalendarEvents[i].ID == MyBusyTimeLine.TimeLineID)
{
string ThirdPartyID = MyArrayOfSubCalendarEvents[i].ThirdPartyID;
MyArrayOfSubCalendarEvents[i] = new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine, MyArrayOfSubCalendarEvents[i].Rigid, MyArrayOfSubCalendarEvents[i].myLocation, AllEventDictionary[ParentID].RangeTimeLine);
MyArrayOfSubCalendarEvents[i].ThirdPartyID = ThirdPartyID;
}
}
}
}
}
}
else
{
if (MyCalendarEventUpdated==null)
{
MyCalendarEventUpdated = MyEvent;
}
}
return MyCalendarEventUpdated;
}
else
{
for (i = 0; i < FreeSpotsAvailableWithinValidTimeline.Count; i++)
{
TotalFreeTimeAvailable += FreeSpotsAvailableWithinValidTimeline[i].TimelineSpan;
}
//if (TotalFreeTimeAvailable >= MyEvent.ActiveDuration)
{
/*TimeLineArrayWithSubEventsAssigned = SplitFreeSpotsInToSubEventTimeSlots(FreeSpotsAvailableWithinValidTimeline.ToArray(), MyEvent.AllEvents.Length, MyEvent.ActiveDuration);
if (TimeLineArrayWithSubEventsAssigned == null)*/
{
BusyTimeLine[] CompleteScheduleOccupiedSlots = CompleteSchedule.OccupiedSlots;
KeyValuePair<CalendarEvent, TimeLine> TimeLineAndCalendarUpdated = ReArrangeTimeLineWithinWithinCalendaEventRange(MyEvent, NoneCOmmitedCalendarEvent.ToList());
CalendarEvent MyCalendarEventUpdated = TimeLineAndCalendarUpdated.Key;
//CompleteSchedule.OccupiedSlots = TimeLineAndCalendarUpdated.Value.OccupiedSlots;//hack need to review architecture to avoid this assignment
if (MyCalendarEventUpdated != null)// && !MyCalendarEventUpdated.ErrorStatus)
{
string MyEventParentID = (new EventID(MyEvent.ID)).getLevelID(0);
foreach (BusyTimeLine MyBusyTimeLine in TimeLineAndCalendarUpdated.Value.OccupiedSlots)
{
string ParentID = (new EventID(MyBusyTimeLine.TimeLineID)).getLevelID(0);
if (ParentID != MyEventParentID)
{
SubCalendarEvent[] MyArrayOfSubCalendarEvents;
if (AllEventDictionary[ParentID].RepetitionStatus)
{
bool Verified = AllEventDictionary[ParentID].updateSubEvent(new EventID(MyBusyTimeLine.TimeLineID), new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine, AllEventDictionary[ParentID].Rigid, AllEventDictionary[ParentID].myLocation));
}
else
{
MyArrayOfSubCalendarEvents = AllEventDictionary[ParentID].AllEvents;
for (i = 0; i < MyArrayOfSubCalendarEvents.Length; i++)
{
if (MyArrayOfSubCalendarEvents[i].ID == MyBusyTimeLine.TimeLineID)
{
string ThirdPartyID = MyArrayOfSubCalendarEvents[i].ThirdPartyID;
MyArrayOfSubCalendarEvents[i] = new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine, MyArrayOfSubCalendarEvents[i].Rigid, MyArrayOfSubCalendarEvents[i].myLocation, AllEventDictionary[ParentID].RangeTimeLine);
MyArrayOfSubCalendarEvents[i].ThirdPartyID = ThirdPartyID;
}
}
}
}
}
/*if (MyCalendarEventUpdated.RepetitionStatus)
{
for (i = 0; i < MyEvent.Repeat.RecurringCalendarEvents.Length; i++)
{
MyCalendarEventUpdated.Repeat.RecurringCalendarEvents[i] = EvaluateTotalTimeLineAndAssignValidTimeSpots(MyEvent.Repeat.RecurringCalendarEvents[i]);
}
}*/
return MyCalendarEventUpdated;
}
}
}
/*else
{
//MessageBox.Show("Sorry, the total free time available during activiy limits is less than your active duration!!!");
List<CalendarEvent> ListOfCalendarEventsWithLatterDeadlines = new System.Collections.Generic.List<CalendarEvent>();
return new CalendarEvent(new CustomErrors(true, "There isnt enough time in for the time space"));
}
*/
if (TimeLineArrayWithSubEventsAssigned.Length < MyEvent.AllEvents.Length)// This means the assigned time per subevent spots won't be sufficient for the subevents available to the calendar event
{
return null;
}
i = 0;
for (; i < MyEvent.AllEvents.Length; i++)
{
TempSubEvent = new SubCalendarEvent(TimeLineArrayWithSubEventsAssigned[i].TimelineSpan, TimeLineArrayWithSubEventsAssigned[i].Start, TimeLineArrayWithSubEventsAssigned[i].End, MyEvent.Preparation, MyEvent.ID, MyEvent.Rigid, MyEvent.myLocation, MyEvent.RangeTimeLine);
MyTempBusyTimerLine = new BusyTimeLine(TempSubEvent.ID, TimeLineArrayWithSubEventsAssigned[i].Start, TimeLineArrayWithSubEventsAssigned[i].End);
TempSubEvent = new SubCalendarEvent(TempSubEvent.ID, TimeLineArrayWithSubEventsAssigned[i].Start.Add(-MyEvent.Preparation), TimeLineArrayWithSubEventsAssigned[i].End, MyTempBusyTimerLine, MyEvent.Rigid, MyEvent.myLocation, MyEvent.RangeTimeLine);
MyEvent.AllEvents[i] = TempSubEvent;
}
}
return MyEvent;
}
public BusyTimeLine updateBusyTimeLine(BusyTimeLine BusyTimeLineEntry)
{
StartTime = BusyTimeLineEntry.StartTime;
EndTime = BusyTimeLineEntry.EndTime;
TimeLineEventID = BusyTimeLineEntry.ID;
return this;
}
