KeyValuePair<CalendarEvent, TimeLine> ReArrangeClashingEventsofRigid(CalendarEvent MyCalendarEvent, List<CalendarEvent> NoneCommitedCalendarEventsEvents, int CurrentEventStatus)// 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
{
/*
Name{: Jerome Biotidara
* this function is responsible for making sure there is some dynamic allotment of time to the subeevents. It takes a calendarevent of a a rigid event. It attempts to rearrange elements around this event. It detects any clashing events and tries to rearrange any non rigid clashing events
*/
HashSet<SubCalendarEvent> NotDoneYetEvents = getNoneDoneYetBetweenNowAndReerenceStartTIme();
//AllEventDictionary.Add(MyCalendarEvent.ID, MyCalendarEvent);
NoneCommitedCalendarEventsEvents.Add(MyCalendarEvent);
/*SubCalendarEvent[] ArrayOfInterferringSubEvents = getInterferringSubEvents(MyCalendarEvent, NoneCommitedCalendarEventsEvents);//It gets all the subevents within the time frame
if (ArrayOfInterferringSubEvents.Length > 0)
{
}
else
{
NoneCommitedCalendarEventsEvents.Remove(MyCalendarEvent);//removes my cal event
return new KeyValuePair<CalendarEvent, TimeLine>(null, null);
}
*/
Tuple<TimeLine, IEnumerable<SubCalendarEvent>, CustomErrors> allInterferringSubCalEventsAndTimeLine = getAllInterferringEventsAndTimeLineInCurrentEvaluation(MyCalendarEvent, NoneCommitedCalendarEventsEvents,CurrentEventStatus,NotDoneYetEvents);
SubCalendarEvent[] ArrayOfInterferringSubEvents = allInterferringSubCalEventsAndTimeLine.Item2.ToArray();
TimeLine RangeForScheduleUpdate = allInterferringSubCalEventsAndTimeLine.Item1;
TimeSpan SumOfAllEventsTimeSpan = Utility.SumOfActiveDuration(ArrayOfInterferringSubEvents);
int i = 0;
Dictionary<CalendarEvent, List<SubCalendarEvent>> DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = new Dictionary<CalendarEvent, List<SubCalendarEvent>>();
List<SubCalendarEvent> RigidSubCalendarEvents = new List<SubCalendarEvent>(0);
RigidSubCalendarEvents = ArrayOfInterferringSubEvents.Where(obj => obj.Rigid).ToList();
List<BusyTimeLine> RigidSubCalendarEventsBusyTimeLine = new List<BusyTimeLine>(0);
RigidSubCalendarEventsBusyTimeLine = RigidSubCalendarEvents.Select(obj => obj.ActiveSlot).ToList();
i = 0;
double OccupancyOfTimeLineSPan = (double)SumOfAllEventsTimeSpan.Ticks / (double)RangeForScheduleUpdate.TimelineSpan.Ticks;
ArrayOfInterferringSubEvents = Utility.NotInList(ArrayOfInterferringSubEvents.ToList(), RigidSubCalendarEvents).ToArray();//removes rigid elements
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = generateDictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents(ArrayOfInterferringSubEvents.ToList(), NoneCommitedCalendarEventsEvents);
List<CalendarEvent> SortedInterFerringCalendarEvents_Deadline = DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Keys.ToList();
SortedInterFerringCalendarEvents_Deadline = SortedInterFerringCalendarEvents_Deadline.OrderBy(obj => obj.End).ToList();
TimeLine ReferenceTimeLine = RangeForScheduleUpdate.CreateCopy();
ReferenceTimeLine.AddBusySlots(RigidSubCalendarEventsBusyTimeLine.ToArray());//Adds all the rigid elements
TimeLine[] ArrayOfFreeSpots = getOnlyPertinentTimeFrame(getAllFreeSpots_NoCompleteSchedule(ReferenceTimeLine), ReferenceTimeLine).ToArray();
ArrayOfFreeSpots = getOnlyPertinentTimeFrame(ArrayOfFreeSpots, ReferenceTimeLine).ToArray();
Dictionary<TimeLine, List<CalendarEvent>> DictTimeLineAndListOfCalendarevent = new System.Collections.Generic.Dictionary<TimeLine, System.Collections.Generic.List<CalendarEvent>>();
if (ArrayOfInterferringSubEvents.Length == 0)
{
NoneCommitedCalendarEventsEvents.Remove(MyCalendarEvent);//removes my cal event
return new KeyValuePair<CalendarEvent, TimeLine>(null, null);
}
List<List<List<SubCalendarEvent>>> SnugListOfPossibleSubCalendarEventsClumps = BuildAllPossibleSnugLists(SortedInterFerringCalendarEvents_Deadline, MyCalendarEvent, DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents, ReferenceTimeLine, OccupancyOfTimeLineSPan);
//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.
if (!MyCalendarEvent.ErrorStatus && allInterferringSubCalEventsAndTimeLine.Item3.Status)
{
MyCalendarEvent.UpdateError(allInterferringSubCalEventsAndTimeLine.Item3);
}
NoneCommitedCalendarEventsEvents.Remove(MyCalendarEvent);
return EvaluateEachSnugPossibiliyOfSnugPossibility(SnugListOfPossibleSubCalendarEventsClumps, ReferenceTimeLine, MyCalendarEvent);
}
KeyValuePair<CalendarEvent, TimeLine> ReArrangeTimeLineWithinWithinCalendaEventRange(CalendarEvent MyCalendarEvent, List<CalendarEvent> NoneCommitedCalendarEventsEvents)// 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
{
/*
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.
*/
int i = 0;
if (MyCalendarEvent.RepetitionStatus == false)//Artificially generates random subevents for the calendar event
{
SubCalendarEvent[] TempSubCalendarEventsForMyCalendarEvent = new SubCalendarEvent[MyCalendarEvent.NumberOfSplit];
for (i = 0; i < TempSubCalendarEventsForMyCalendarEvent.Length; i++)//populates the subevents for the calendar event
{
TimeSpan MyActiveTimeSpanPerSplit = TimeSpan.FromTicks((long)((MyCalendarEvent.ActiveDuration.Ticks / MyCalendarEvent.NumberOfSplit) ));
TempSubCalendarEventsForMyCalendarEvent[i] = new SubCalendarEvent(MyActiveTimeSpanPerSplit, (MyCalendarEvent.End - MyActiveTimeSpanPerSplit), MyCalendarEvent.End, new TimeSpan(), MyCalendarEvent.ID, MyCalendarEvent.Rigid, MyCalendarEvent.myLocation, MyCalendarEvent.RangeTimeLine);
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.Rigid, MyCalendarEvent.myLocation, MyCalendarEvent.RangeTimeLine);
MyCalendarEvent.AllEvents[i] = TempSubCalendarEventsForMyCalendarEvent[i];
}
}
else
{
throw new Exception("invalid calendar event detected in ReArrangeTimeLineWithinWithinCalendaEventRange. Repat not allowed");
}
TimeLine RangeForScheduleUpdate;
DateTime EarliestStartTime;
DateTime LatestEndTime;
Tuple<IEnumerable<SubCalendarEvent>, DateTime> refinedStartTimeAndInterferringEvents;
NoneCommitedCalendarEventsEvents.Add(MyCalendarEvent);
SubCalendarEvent[] ArrayOfInterferringSubEvents = getInterferringSubEvents(MyCalendarEvent, NoneCommitedCalendarEventsEvents);//It gets all the subevents within the time frame
List<SubCalendarEvent> collectionOfInterferringSubCalEvents;
EarliestStartTime = ArrayOfInterferringSubEvents.OrderBy(obj => obj.getCalendarEventRange.Start).ToList()[0].getCalendarEventRange.Start;
LatestEndTime = ArrayOfInterferringSubEvents.OrderBy(obj => obj.getCalendarEventRange.End).ToList()[ArrayOfInterferringSubEvents.Length - 1].getCalendarEventRange.End;
EarliestStartTime = EarliestStartTime < Now ? Now : EarliestStartTime;
refinedStartTimeAndInterferringEvents = getStartTimeWhenCurrentTimeClashesWithSubcalevent(ArrayOfInterferringSubEvents, EarliestStartTime);
EarliestStartTime = refinedStartTimeAndInterferringEvents.Item2;
ArrayOfInterferringSubEvents = refinedStartTimeAndInterferringEvents.Item1.ToArray();
RangeForScheduleUpdate = new TimeLine(EarliestStartTime, LatestEndTime);
collectionOfInterferringSubCalEvents = getInterferringSubEvents(RangeForScheduleUpdate, NoneCommitedCalendarEventsEvents).ToList();
//collectionOfInterferringSubCalEvents.Add(MyCalendarEvent.AllEvents[0]);//artificially adds the new rigid event
ArrayOfInterferringSubEvents = collectionOfInterferringSubCalEvents.ToArray();
Tuple<TimeLine,IEnumerable<SubCalendarEvent>> allInterferringSubCalEventsAndTimeLine = getAllInterferringEventsAndTimeLineInCurrentEvaluation(ArrayOfInterferringSubEvents, NoneCommitedCalendarEventsEvents, RangeForScheduleUpdate);
ArrayOfInterferringSubEvents = allInterferringSubCalEventsAndTimeLine.Item2.ToArray();
RangeForScheduleUpdate=allInterferringSubCalEventsAndTimeLine.Item1;
TimeSpan SumOfAllEventsTimeSpan = Utility.SumOfActiveDuration(ArrayOfInterferringSubEvents);
/*
ArrayOfInterferringSubEvents.OrderBy(obj => obj.End);//SortSubCalendarEvents(ArrayOfInterferringSubEvents.ToList(), false).ToArray();
List<IDefinedRange>[] MyEdgeElements = getEdgeElements(RangeForScheduleUpdate, ArrayOfInterferringSubEvents);
EarliestStartTime = MyEdgeElements[0].Count > 0 ? MyEdgeElements[0].OrderBy(obj => obj.Start).ToList()[0].Start : RangeForScheduleUpdate.Start;
LatestEndTime = MyEdgeElements[1].Count > 0 ? MyEdgeElements[1].OrderBy(obj => obj.End).ToList()[MyEdgeElements[1].Count - 1].End : RangeForScheduleUpdate.End;
EarliestStartTime = EarliestStartTime < Now ? Now : EarliestStartTime;
refinedStartTimeAndInterferringEvents = getStartTimeWhenCurrentTimeClashesWithSubcalevent(ArrayOfInterferringSubEvents, EarliestStartTime);
EarliestStartTime = refinedStartTimeAndInterferringEvents.Item2;
ArrayOfInterferringSubEvents = refinedStartTimeAndInterferringEvents.Item1.ToArray();
RangeForScheduleUpdate = new TimeLine(EarliestStartTime, LatestEndTime);
TimeSpan SumOfAllEventsTimeSpan = Utility.SumOfActiveDuration(ArrayOfInterferringSubEvents.ToList());//sum all events
while (SumOfAllEventsTimeSpan >= RangeForScheduleUpdate.TimelineSpan)//loops untill the sum all the interferring events can possibly fit within the timeline. Essentially possibly fittable
{
EarliestStartTime = ArrayOfInterferringSubEvents.OrderBy(obj => obj.getCalendarEventRange.Start).ToList()[0].getCalendarEventRange.Start;//attempts to get subcalevent with a calendarevent with earliest start time
LatestEndTime = ArrayOfInterferringSubEvents.OrderBy(obj => obj.getCalendarEventRange.End).ToList()[ArrayOfInterferringSubEvents.Length - 1].getCalendarEventRange.End;//attempts to get subcalevent with a calendarevent with latest Endtime
EarliestStartTime = EarliestStartTime < Now ? Now : EarliestStartTime;
refinedStartTimeAndInterferringEvents = getStartTimeWhenCurrentTimeClashesWithSubcalevent(ArrayOfInterferringSubEvents, EarliestStartTime);
EarliestStartTime = refinedStartTimeAndInterferringEvents.Item2;
ArrayOfInterferringSubEvents = refinedStartTimeAndInterferringEvents.Item1.ToArray();
RangeForScheduleUpdate = new TimeLine(EarliestStartTime, LatestEndTime);//updates range of scan
collectionOfInterferringSubCalEvents = getInterferringSubEvents(RangeForScheduleUpdate, NoneCommitedCalendarEventsEvents).ToList();//updates interferring events list
ArrayOfInterferringSubEvents = collectionOfInterferringSubCalEvents.ToArray();
ArrayOfInterferringSubEvents.OrderBy(obj => obj.End);
MyEdgeElements = getEdgeElements(RangeForScheduleUpdate, ArrayOfInterferringSubEvents);
EarliestStartTime = MyEdgeElements[0].Count > 0 ? MyEdgeElements[0].OrderBy(obj => obj.Start).ToList()[0].Start : RangeForScheduleUpdate.Start;
LatestEndTime = MyEdgeElements[1].Count > 0 ? MyEdgeElements[1].OrderBy(obj => obj.End).ToList()[MyEdgeElements[1].Count - 1].End : RangeForScheduleUpdate.End;
EarliestStartTime = EarliestStartTime < Now ? Now : EarliestStartTime;
refinedStartTimeAndInterferringEvents = getStartTimeWhenCurrentTimeClashesWithSubcalevent(ArrayOfInterferringSubEvents, EarliestStartTime);
EarliestStartTime = refinedStartTimeAndInterferringEvents.Item2;
ArrayOfInterferringSubEvents = refinedStartTimeAndInterferringEvents.Item1.ToArray();
RangeForScheduleUpdate = new TimeLine(EarliestStartTime, LatestEndTime);
TimeSpan newSumOfAllTimeSpans = Utility.SumOfActiveDuration(ArrayOfInterferringSubEvents.ToList());
if (newSumOfAllTimeSpans == SumOfAllEventsTimeSpan)
{
throw new Exception("You have events that cannot fit our time frame");
}
else
{
SumOfAllEventsTimeSpan = newSumOfAllTimeSpans;
}
}*/
Dictionary<CalendarEvent, List<SubCalendarEvent>> DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = new Dictionary<CalendarEvent, List<SubCalendarEvent>>();
List<SubCalendarEvent> RigidSubCalendarEvents = new List<SubCalendarEvent>(0);
List<BusyTimeLine> RigidSubCalendarEventsBusyTimeLine = new List<BusyTimeLine>(0);
RigidSubCalendarEvents = ArrayOfInterferringSubEvents.Where(obj => obj.Rigid).ToList();
RigidSubCalendarEventsBusyTimeLine = RigidSubCalendarEvents.Select(obj => obj.ActiveSlot).ToList();
double OccupancyOfTimeLineSPan = (double)SumOfAllEventsTimeSpan.Ticks / (double)RangeForScheduleUpdate.TimelineSpan.Ticks;
ArrayOfInterferringSubEvents = Utility.NotInList(ArrayOfInterferringSubEvents.ToList(), RigidSubCalendarEvents).ToArray();//remove rigid elements
//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(), NoneCommitedCalendarEventsEvents);//generates a dictionary of a Calendar Event and the interferring events in the respective Calendar event
//DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(MyCalendarEvent, MyCalendarEvent.AllEvents.ToList());//artificially adds enew calendar event to dictionary
List<CalendarEvent> SortedInterFerringCalendarEvents_Deadline = DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Keys.ToList();
SortedInterFerringCalendarEvents_Deadline = SortedInterFerringCalendarEvents_Deadline.OrderBy(obj => obj.End).ToList();
TimeLine ReferenceTimeLine = RangeForScheduleUpdate.CreateCopy();
ReferenceTimeLine.AddBusySlots(RigidSubCalendarEventsBusyTimeLine.ToArray());//Adds all the rigid elements
TimeLine[] ArrayOfFreeSpots = getOnlyPertinentTimeFrame(getAllFreeSpots_NoCompleteSchedule(ReferenceTimeLine), ReferenceTimeLine).ToArray();
ArrayOfFreeSpots = getOnlyPertinentTimeFrame(ArrayOfFreeSpots, ReferenceTimeLine).ToArray();
Dictionary<TimeLine, List<CalendarEvent>> DictTimeLineAndListOfCalendarevent = new System.Collections.Generic.Dictionary<TimeLine, System.Collections.Generic.List<CalendarEvent>>();
List<List<List<SubCalendarEvent>>> SnugListOfPossibleSubCalendarEventsClumps = BuildAllPossibleSnugLists(SortedInterFerringCalendarEvents_Deadline, MyCalendarEvent, DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents, ReferenceTimeLine, OccupancyOfTimeLineSPan);
//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.
List<SubCalendarEvent>SerializedResult=SnugListOfPossibleSubCalendarEventsClumps[0].SelectMany(obj => obj).ToList();
int TotalUpdatedSchedule= SerializedResult.Count+RigidSubCalendarEvents.Count;
if (TotalUpdatedSchedule != collectionOfInterferringSubCalEvents.Count)
{
MyCalendarEvent.UpdateError(new CustomErrors(true, "There is a clash in event"));
}
NoneCommitedCalendarEventsEvents.Remove(MyCalendarEvent);
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
}
public CalendarEvent EvaluateTotalTimeLineAndAssignValidTimeSpots(CalendarEvent MyEvent,HashSet<SubCalendarEvent> UnDoneEvents, List<CalendarEvent> NoneCOmmitedCalendarEvent = null, int InterringWithNowEvent=0)
{
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], UnDoneEvents, NoneCOmmitedCalendarEvent);
NoneCOmmitedCalendarEvent.Add(MyEvent.Repeat.RecurringCalendarEvents[i]);
if (MyEvent.Repeat.RecurringCalendarEvents[i].ErrorStatus)
{
MyEvent.UpdateError(MyEvent.Repeat.RecurringCalendarEvents[i].Error);
}
}
return MyEvent;
}
BusyTimeLine[] AllOccupiedSlot = CompleteSchedule.OccupiedSlots;
TimeSpan TotalActiveDuration = new TimeSpan();
TimeLine[] TimeLineArrayWithSubEventsAssigned = new TimeLine[MyEvent.ActiveSubEvents.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.isEnabled, MyEvent.UIParam, MyEvent.Notes, MyEvent.isComplete, 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, TempSubEvent.isEnabled, TempSubEvent.UIParam, TempSubEvent.Notes, TempSubEvent.isComplete, MyEvent.myLocation, MyEvent.RangeTimeLine);
MyEvent.updateSubEvent(TempSubEvent.SubEvent_ID, TempSubEvent);
KeyValuePair<CalendarEvent, TimeLine> TimeLineAndCalendarUpdated = ReArrangeClashingEventsofRigid(MyEvent, NoneCOmmitedCalendarEvent.ToList(), InterringWithNowEvent);
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));
SubCalendarEvent referenceSubCalEvent = AllEventDictionary[ParentID].getSubEvent(new EventID(MyBusyTimeLine.TimeLineID));
referenceSubCalEvent.shiftEvent(MyBusyTimeLine.Start - referenceSubCalEvent.Start);
}
else
{
MyArrayOfSubCalendarEvents = AllEventDictionary[ParentID].AllSubEvents;
for (i = 0; i < MyArrayOfSubCalendarEvents.Length; i++)
{
if (MyArrayOfSubCalendarEvents[i].ID == MyBusyTimeLine.TimeLineID)
{
//string ThirdPartyID = MyArrayOfSubCalendarEvents[i].ThirdPartyID;
//SubCalendarEvent newSubCalevent = new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine, MyArrayOfSubCalendarEvents[i].Rigid, MyArrayOfSubCalendarEvents[i].myLocation, AllEventDictionary[ParentID].RangeTimeLine);
//newSubCalevent.ThirdPartyID = ThirdPartyID;
//AllEventDictionary[ParentID].updateSubEvent(newSubCalevent.SubEvent_ID, newSubCalevent);
SubCalendarEvent referenceSubCalEvent = MyArrayOfSubCalendarEvents[i];
referenceSubCalEvent.shiftEvent(MyBusyTimeLine.Start - referenceSubCalEvent.Start);
}
}
}
}
}
}
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(), InterringWithNowEvent, UnDoneEvents);
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));
SubCalendarEvent referenceSubCalEvent = AllEventDictionary[ParentID].getSubEvent(new EventID(MyBusyTimeLine.TimeLineID));
referenceSubCalEvent.shiftEvent(MyBusyTimeLine.Start - referenceSubCalEvent.Start);
}
else
{
MyArrayOfSubCalendarEvents = AllEventDictionary[ParentID].ActiveSubEvents;
for (i = 0; i < MyArrayOfSubCalendarEvents.Length; i++)
{
if (MyArrayOfSubCalendarEvents[i] != null)//for procrastinate scenario where subcalevents get removed
{
if (MyArrayOfSubCalendarEvents[i].ID == MyBusyTimeLine.TimeLineID)
{
/*string ThirdPartyID = MyArrayOfSubCalendarEvents[i].ThirdPartyID;
SubCalendarEvent newSubCalevent = new SubCalendarEvent(MyBusyTimeLine.TimeLineID, MyBusyTimeLine.Start, MyBusyTimeLine.End, MyBusyTimeLine, MyArrayOfSubCalendarEvents[i].Rigid, MyArrayOfSubCalendarEvents[i].myLocation, AllEventDictionary[ParentID].RangeTimeLine);
newSubCalevent.ThirdPartyID = ThirdPartyID;
AllEventDictionary[ParentID].updateSubEvent(newSubCalevent.SubEvent_ID, newSubCalevent);*/
SubCalendarEvent referenceSubCalEvent = MyArrayOfSubCalendarEvents[i];
referenceSubCalEvent.shiftEvent(MyBusyTimeLine.Start - referenceSubCalEvent.Start);
}
}
}
}
}
}
/*if (MyCalendarEventUpdated.RepetitionStatus)
{
for (i = 0; i < MyEvent.Repeat.RecurringCalendarEvents.Length; i++)
{
MyCalendarEventUpdated.Repeat.RecurringCalendarEvents[i] = EvaluateTotalTimeLineAndAssignValidTimeSpots(MyEvent.Repeat.RecurringCalendarEvents[i]);
}
}*/
return MyCalendarEventUpdated;
}
else
{
throw new Exception("code generated a null calendar event. THis is weird");
}
}
}
/*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.AllSubEvents.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.AllActiveSubEvents.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.updateSubEvent(TempSubEvent.SubEvent_ID, TempSubEvent);
}
*/
}
return MyEvent;
}