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 CalendarEvent()
{
EventDuration = new TimeSpan();
CalendarEventName = "";
StartDateTime = new DateTime();
EndDateTime = new DateTime();
EventPreDeadline = new TimeSpan();
PrepTime = new TimeSpan();
Priority = 0;
RepetitionFlag = false;
EventRepetition = new Repetition();
RigidSchedule = false;
Splits = 1;
LocationData = new Location();
CalendarEventID = new EventID("");
ArrayOfSubEvents = new SubCalendarEvent[0];
SchedulStatus = false;
otherPartyID = "";
CalendarError = new CustomErrors(false, string.Empty);
EventSequence = new TimeLine();
}
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;
}
public CalendarEvent(CustomErrors Error)
{
EventDuration = new TimeSpan();
CalendarEventName = "";
StartDateTime = new DateTime();
EndDateTime = new DateTime();
EventPreDeadline = new TimeSpan();
PrepTime = new TimeSpan();
Priority = 0;
RepetitionFlag = false;
EventRepetition = new Repetition();
RigidSchedule = false;
Splits = 1;
LocationData = new Location();
CalendarEventID = new EventID("");
SubEvents = new Dictionary<EventID, SubCalendarEvent>();
SchedulStatus = false;
otherPartyID = "";
CalendarError = Error;
EventSequence = new TimeLine();
}
public CalendarEvent(EventID EventIDEntry, string EventName, TimeSpan Event_Duration, DateTime EventStart, DateTime EventDeadline, TimeSpan EventPrepTime, TimeSpan Event_PreDeadline, bool EventRigidFlag, Repetition EventRepetitionEntry, int EventSplit, Location EventLocation, bool enabledFlag, EventDisplay UiData, MiscData NoteData, bool CompletionFlag)
{
CalendarEventName = EventName;
StartDateTime = EventStart;
EndDateTime = EventDeadline;
EventDuration = Event_Duration;
Enabled = enabledFlag;
EventRepetition = EventRepetitionEntry;
PrepTime = EventPrepTime;
EventPreDeadline = Event_PreDeadline;
RigidSchedule = EventRigidFlag;
LocationData = EventLocation;
CalendarEventID = EventIDEntry;
UiParams = UiData;
DataBlob = NoteData;
Complete = CompletionFlag;
if (EventRepetition.Enable)
{
Splits = EventSplit;
TimePerSplit = new TimeSpan();
}
else
{
Splits = EventSplit;
TimePerSplit = TimeSpan.FromTicks(((EventDuration.Ticks / Splits)));
}
SubEvents = new Dictionary<EventID, SubCalendarEvent>();
for (int i = 0; i < Splits; i++)
{
//(TimeSpan Event_Duration, DateTime EventStart, DateTime EventDeadline, TimeSpan EventPrepTime, string myParentID, bool Rigid, Location EventLocation =null, TimeLine RangeOfSubCalEvent = null)
SubCalendarEvent newSubCalEvent = new SubCalendarEvent(TimePerSplit, (EndDateTime - TimePerSplit), this.End, new TimeSpan(), CalendarEventID.ToString(), RigidSchedule,this.isEnabled, this.UiParams,this.Notes,this.Complete, EventLocation, this.RangeTimeLine);
SubEvents.Add(newSubCalEvent.SubEvent_ID, newSubCalEvent);
}
EventSequence = new TimeLine(StartDateTime, EndDateTime);
UpdateLocationMatrix(EventLocation);
}
virtual public bool updateSubEvent(EventID SubEventID,SubCalendarEvent UpdatedSubEvent)
{
if (this.RepetitionStatus)
{
foreach (CalendarEvent MyCalendarEvent in Repeat.RecurringCalendarEvents)
{
if (MyCalendarEvent.updateSubEvent(SubEventID, UpdatedSubEvent))
{
return true;
}
}
}
else
{
int i = 0;
for (i = 0; i < ArrayOfSubEvents.Length;i++)
{
if (ArrayOfSubEvents[i].ID == SubEventID.ToString())
{
SubCalendarEvent NewSubCalEvent = new SubCalendarEvent(UpdatedSubEvent.ID, UpdatedSubEvent.Start, UpdatedSubEvent.End, UpdatedSubEvent.ActiveSlot, UpdatedSubEvent.Rigid, UpdatedSubEvent.myLocation, this.RangeTimeLine);
string thirdPartyID = ArrayOfSubEvents[i].ThirdPartyID;
ArrayOfSubEvents[i] = NewSubCalEvent;
ArrayOfSubEvents[i].ThirdPartyID = thirdPartyID;
return true;
}
}
}
return false;
}
public CalendarEvent(string EventName, TimeSpan Event_Duration, DateTime EventStart, DateTime EventDeadline, TimeSpan EventPrepTime, TimeSpan Event_PreDeadline, bool EventRigidFlag, Repetition EventRepetitionEntry, int EventSplit, Location EventLocation)
{
CalendarEventName = EventName;
/*CalendarEventName = EventName.Split(',')[0];
LocationString = "";
if (EventName.Split(',').Length > 1)
{
LocationString = EventName.Split(',')[1];
}
CalendarEventLocation = null;
CalendarEventLocation = new Location();
if (LocationString != "")
{
CalendarEventLocation = new Location(LocationString);
}
*/
StartDateTime = EventStart;
EndDateTime = EventDeadline;
EventDuration = Event_Duration;
Splits = EventSplit;
PrepTime = EventPrepTime;
EventPreDeadline = Event_PreDeadline;
RigidSchedule = EventRigidFlag;
TimePerSplit = TimeSpan.FromTicks(((EventDuration.Ticks / Splits)));
ArrayOfSubEvents = new SubCalendarEvent[Splits];
CalendarEventID = new EventID(new string[] { EventIDGenerator.generate().ToString() });
EventRepetition = EventRepetitionEntry;
LocationData = EventLocation;
EventSequence = new TimeLine(StartDateTime, EndDateTime);
UpdateLocationMatrix(LocationData);
}
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;
}
public TimeSpanWithEventID(long ticks,EventID ID)
{
timeSpan=new TimeSpan(ticks);
TimeSpanID = ID;
}
public TimeSpanWithEventID(TimeSpan TimeSpanEntry, EventID ID)
{
timeSpan = TimeSpanEntry;
TimeSpanID = ID;
}
public CalendarEvent(CalendarEvent MyUpdated, SubCalendarEvent[] MySubEvents)
{
CalendarEventName = MyUpdated.Name;
StartDateTime = MyUpdated.StartDateTime;
EndDateTime = MyUpdated.End;
EventSequence = new TimeLine(StartDateTime, EndDateTime);
EventDuration = MyUpdated.ActiveDuration;
Splits = MyUpdated.Splits;
PrepTime = MyUpdated.PrepTime;
EventPreDeadline = MyUpdated.PreDeadline;
RigidSchedule = MyUpdated.Rigid;
TimePerSplit = MyUpdated.TimePerSplit;
if (MyUpdated.ID != null)
{
CalendarEventID = new EventID(MyUpdated.ID.Split('_'));
}
Enabled = MyUpdated.isEnabled;
SubEvents = new Dictionary<EventID, SubCalendarEvent>();
for (int i = 0; i < MySubEvents.Length; i++)//using MySubEvents.length for the scenario of the call for repeat event. Remember the parent event does not generate subevents
{
SubCalendarEvent newSubCalEvent = MySubEvents[i];
if (SubEvents.ContainsKey(newSubCalEvent.SubEvent_ID))
{
SubEvents[newSubCalEvent.SubEvent_ID]=newSubCalEvent;
}
else
{
SubEvents.Add(newSubCalEvent.SubEvent_ID, newSubCalEvent);
}
}
SchedulStatus = false;
EventRepetition = MyUpdated.Repeat;
LocationData = MyUpdated.LocationData;
UpdateLocationMatrix(LocationData);
EventSequence = new TimeLine(StartDateTime, EndDateTime);
}
public virtual bool updateSubEvent(EventID SubEventID,SubCalendarEvent UpdatedSubEvent)
{
if (this.RepetitionStatus)
{
foreach (CalendarEvent MyCalendarEvent in Repeat.RecurringCalendarEvents)
{
if (MyCalendarEvent.updateSubEvent(SubEventID, UpdatedSubEvent))
{
return true;
}
}
}
else
{
if (SubEvents.ContainsKey(SubEventID))
{
SubCalendarEvent NewSubCalEvent = new SubCalendarEvent(SubEventID.ToString(), UpdatedSubEvent.Start, UpdatedSubEvent.End, UpdatedSubEvent.ActiveSlot, UpdatedSubEvent.Rigid, UpdatedSubEvent.isEnabled, UpdatedSubEvent.UiParams, UpdatedSubEvent.Notes, UpdatedSubEvent.Complete, UpdatedSubEvent.myLocation, this.RangeTimeLine);
SubCalendarEvent CurrentSubEvent = SubEvents[SubEventID];
NewSubCalEvent.ThirdPartyID = CurrentSubEvent.ThirdPartyID;
SubEvents[SubEventID] = NewSubCalEvent;//using method as opposed to the UpdateThis function because of the canexistwithintimeline function test in the UpdateThis function
return true;
}
}
return false;
}
//CalendarEvent Methods
public SubCalendarEvent getSubEvent(EventID SubEventID)
{
int i = 0;
if (Repeat.Enable)
{
foreach (CalendarEvent MyCalendarEvent in EventRepetition.RecurringCalendarEvents)
{
SubCalendarEvent MySubEvent = MyCalendarEvent.getSubEvent(SubEventID);
if (MySubEvent != null)
{
return MySubEvent;
}
}
}
else
{
if (SubEvents.ContainsKey(SubEventID))
{
return SubEvents[SubEventID];
}
}
return null;
}
public CalendarEvent(string EventName, TimeSpan Event_Duration, DateTime EventStart, DateTime EventDeadline, TimeSpan EventPrepTime, TimeSpan Event_PreDeadline, bool EventRigidFlag, Repetition EventRepetitionEntry, int EventSplit, Location EventLocation, bool EnableFlag, EventDisplay UiData, MiscData NoteData, bool CompletionFlag)
{
CalendarEventName = EventName;
/*CalendarEventName = EventName.Split(',')[0];
LocationString = "";
if (EventName.Split(',').Length > 1)
{
LocationString = EventName.Split(',')[1];
}
CalendarEventLocation = null;
CalendarEventLocation = new Location();
if (LocationString != "")
{
CalendarEventLocation = new Location(LocationString);
}
*/
StartDateTime = EventStart;
EndDateTime = EventDeadline;
EventDuration = Event_Duration;
PrepTime = EventPrepTime;
EventPreDeadline = Event_PreDeadline;
RigidSchedule = EventRigidFlag;
LocationData = EventLocation;
CalendarEventID = new EventID(new string[] { EventIDGenerator.generate().ToString() });
EventRepetition = EventRepetitionEntry;
UiParams = UiData;
DataBlob = NoteData;
Complete = CompletionFlag;
if (EventRepetition.Enable)
{
Splits = EventSplit;
TimePerSplit = new TimeSpan();
}
else
{
Splits = EventSplit;
TimePerSplit = TimeSpan.FromTicks(((EventDuration.Ticks / Splits)));
}
SubEvents = new Dictionary<EventID, SubCalendarEvent>();
for (int i = 0; i < Splits; i++)
{
SubCalendarEvent newSubCalEvent = new SubCalendarEvent(TimePerSplit, (EndDateTime - TimePerSplit), this.End, new TimeSpan(), CalendarEventID.ToString(), RigidSchedule, this.Enabled, this.UiParams, this.Notes, this.Complete, EventLocation, this.RangeTimeLine); //new SubCalendarEvent(CalendarEventID);
SubEvents.Add(newSubCalEvent.SubEvent_ID, newSubCalEvent);
}
EventSequence = new TimeLine(StartDateTime, EndDateTime);
UpdateLocationMatrix(LocationData);
}
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;
}
}
public CalendarEvent getCalendarEvent(EventID myEventID)
{
return AllEventDictionary[myEventID.ID[0]];
}
public TimeSpanWithEventID(int days, int hours, int minutes, int seconds, int milliseconds, EventID ID)
{
timeSpan = new TimeSpan(days, hours, minutes, seconds);
TimeSpanID = new EventID(ID.ToString());
}
public void FindNewSlotForSubEvent(EventID MyEventID)
{
return;
}
//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;
}
//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;
}
KeyValuePair<CalendarEvent, TimeLine> EvaluateEachSnugPossibiliyOfSnugPossibility(List<List<List<SubCalendarEvent>>> SnugPossibilityPermutation, TimeLine ReferenceTimeLine, CalendarEvent ReferenceCalendarEvent)
{
TimeLine CopyOfReferenceTimeLine;
List<TimeLine> SnugPossibilityTimeLine = new System.Collections.Generic.List<TimeLine>();
Dictionary<BusyTimeLine, SubCalendarEvent> MyBusyTimeLineToSubCalendarEventDict = new System.Collections.Generic.Dictionary<BusyTimeLine, SubCalendarEvent>();
foreach (List<List<SubCalendarEvent>> SnugPermutation in SnugPossibilityPermutation)//goes each permutation of snug possibility generated
{
CopyOfReferenceTimeLine = ReferenceTimeLine.CreateCopy();
//SnugPossibilityTimeLine.Add(CopyOfReferenceTimeLine);
List<TimeLine> ListOfFreeSpots=getOnlyPertinentTimeFrame(getAllFreeSpots_NoCompleteSchedule(CopyOfReferenceTimeLine), CopyOfReferenceTimeLine);
List<SubCalendarEvent> ReassignedSubEvents = new System.Collections.Generic.List<SubCalendarEvent>();
for (int i=0; i<ListOfFreeSpots.Count;i++)
{
DateTime RelativeStartTime = ListOfFreeSpots[i].Start;
foreach (SubCalendarEvent MySubCalendarEvent in SnugPermutation[i])
{
SubCalendarEvent CopyOfMySubCalendarEvent = MySubCalendarEvent.createCopy();
TimeSpan MySubCalendarDuration = (CopyOfMySubCalendarEvent.End - CopyOfMySubCalendarEvent.Start);
DateTime RelativeEndtime = RelativeStartTime + MySubCalendarDuration;
CopyOfMySubCalendarEvent.ReassignTime(RelativeStartTime, RelativeEndtime);
CopyOfMySubCalendarEvent.ActiveSlot = new BusyTimeLine(CopyOfMySubCalendarEvent.ID, RelativeStartTime, RelativeEndtime);//Note this is a hack to resolve the reassignment of time since we dont know currently know the distiction between BusyTimeLine and SubCalendarEvent(TimeLine)
TimeLine MyTimeLine=CopyOfMySubCalendarEvent.EventTimeLine;
CopyOfReferenceTimeLine.MergeTimeLines(MyTimeLine);
RelativeStartTime = CopyOfMySubCalendarEvent.End;
MyBusyTimeLineToSubCalendarEventDict.Add(CopyOfMySubCalendarEvent.ActiveSlot, CopyOfMySubCalendarEvent);
}
}
SnugPossibilityTimeLine.Add(CopyOfReferenceTimeLine);
}
Dictionary<CalendarEvent, TimeLine> CalendarEvent_EvaluationIndexDict = new System.Collections.Generic.Dictionary<CalendarEvent, TimeLine>();
Dictionary<string, double> DictionaryGraph = new System.Collections.Generic.Dictionary<string, double>();
foreach (TimeLine MyTimeLine in SnugPossibilityTimeLine)
{
CalendarEvent MyEventCopy=ReferenceCalendarEvent.createCopy();
foreach (BusyTimeLine MyBusyPeriod in MyTimeLine.OccupiedSlots)
{
EventID MyEventID = new EventID(MyBusyPeriod.TimeLineID);
string ParentCalendarEventID = MyEventID.getLevelID(0);
if (MyEventCopy.ID == ParentCalendarEventID)
{
SubCalendarEvent MySubCalendarEvent=MyBusyTimeLineToSubCalendarEventDict[MyBusyPeriod];
for (int i = 0; i < MyEventCopy.AllEvents.Length; i++)
{
if (MyEventCopy.AllEvents[i].ID == MySubCalendarEvent.ID)
{
MyEventCopy.AllEvents[i] = MySubCalendarEvent;
break;
}
}
}
}
//MyEventCopy=EvaluateTotalTimeLineAndAssignValidTimeSpotsWithReferenceTimeLine(MyEventCopy, MyTimeLine);
CalendarEvent_EvaluationIndexDict.Add(MyEventCopy, MyTimeLine);
}
double HighestValue=0;
KeyValuePair<CalendarEvent, TimeLine> FinalSuggestion = new System.Collections.Generic.KeyValuePair<CalendarEvent,TimeLine>();
TimeLine TimeLineUpdated = null;
Dictionary<string, double> LocationVector = new System.Collections.Generic.Dictionary<string,double>();
LocationVector.Add("sameElement", 10000000000);
foreach (KeyValuePair<CalendarEvent, TimeLine> MyCalendarEvent_TimeLine in CalendarEvent_EvaluationIndexDict)
{
int RandomIndex = EvaluateRandomNetIndex(MyCalendarEvent_TimeLine.Value);
RandomIndex = 0;
LocationVector=BuildDictionaryDistanceEdge(MyCalendarEvent_TimeLine.Value, MyCalendarEvent_TimeLine.Key, LocationVector);
double ClumpIndex = EvaluateClumpingIndex(MyCalendarEvent_TimeLine.Value, LocationVector);
ClumpIndex = 1 / ClumpIndex;
double EvaluationSum = ClumpIndex + RandomIndex;
if (EvaluationSum < 0)
{
EvaluationSum *= -1;
}
if ( EvaluationSum > HighestValue)
{
HighestValue = EvaluationSum;
FinalSuggestion = MyCalendarEvent_TimeLine;
}
}
if (FinalSuggestion.Equals(new KeyValuePair<CalendarEvent,TimeLine>()))
{
MessageBox.Show("Oh oh J, you'll need to look outside this range...Think of moving other events out of white box space");
}
return FinalSuggestion;
}
private CalendarEvent(ConstructorModified UpdatedConstructor, EventID MyEventID, Location EventLocation=null)
: this(MyEventID, UpdatedConstructor.Name, UpdatedConstructor.Duration, UpdatedConstructor.StartDate, UpdatedConstructor.EndDate, UpdatedConstructor.PrepTime, UpdatedConstructor.PreDeadline, UpdatedConstructor.Rigid, UpdatedConstructor.Repeat, UpdatedConstructor.Split, EventLocation)
{
}
Dictionary<CalendarEvent, List<SubCalendarEvent>> generateDictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents(List<SubCalendarEvent> ListOfInterferringElements)
{
/*
Name:Function takes the list of interferring arrays and used to build a Calendar To "List of SubCalendarEvent" dictionary.
*/
int i = 0;
Dictionary<CalendarEvent, List<SubCalendarEvent>> DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = new Dictionary<CalendarEvent, List<SubCalendarEvent>>();
int j = 0;
for (; i < ListOfInterferringElements.Count; i++)
{
EventID MyEventID = new EventID(ListOfInterferringElements[i].ID);
string ParentID=MyEventID.getLevelID(0);//This gets the parentID of the SubCalendarEventID
//try//Try bock attempts to create new dictionary entry for Calendar event. Else it simply adds an element to the list created by the error
{
if (AllEventDictionary[ParentID].RepetitionStatus)
{
CalendarEvent repeatCalEvent=AllEventDictionary[ParentID].getRepeatedCalendarEvent(MyEventID.getStringIDAtLevel(1));
if (DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.ContainsKey(repeatCalEvent))
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[repeatCalEvent].Add(ListOfInterferringElements[i]);
j++;
}
else
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(repeatCalEvent,new List<SubCalendarEvent>());
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[repeatCalEvent].Add(ListOfInterferringElements[i]);
j++;
}
}
else
{
CalendarEvent nonRepeatCalEvent=AllEventDictionary[ParentID];
if (DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.ContainsKey(nonRepeatCalEvent))
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[nonRepeatCalEvent].Add( ListOfInterferringElements[i]);
j++;
}
else
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(nonRepeatCalEvent, new List<SubCalendarEvent>());
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[nonRepeatCalEvent].Add(ListOfInterferringElements[i]);
j++;
}
}
}
/*catch (Exception e)
{
if (AllEventDictionary[ParentID].RepetitionStatus)
{
}
else
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[AllEventDictionary[ParentID]].Add(ListOfInterferringElements[i]);
}
}*/
}
return DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents;
}
public ConstructorModified(string EventIDEntry, string NameEntry, string StartTime, DateTime StartDateEntry, string EndTime, DateTime EventEndDateEntry, string eventSplit, string PreDeadlineTime, string EventDuration, Repetition EventRepetition, bool DefaultPrepTimeflag, bool RigidScheduleFlag, string eventPrepTime, bool PreDeadlineFlag)
{
CalendarEventID = new EventID(EventIDEntry.Split('_'));
Name = NameEntry;
EventDuration=EventDuration.Replace(".", ":");
//EventDuration = EventDuration + ":00";
string MiltaryStartTime = convertTimeToMilitary(StartTime);
StartDate = new DateTime(StartDateEntry.Year, StartDateEntry.Month, StartDateEntry.Day, Convert.ToInt32(MiltaryStartTime.Split(':')[0]), Convert.ToInt32(MiltaryStartTime.Split(':')[1]), 0);
string MiltaryEndTime = convertTimeToMilitary(EndTime);
EndDate = new DateTime(EventEndDateEntry.Year, EventEndDateEntry.Month, EventEndDateEntry.Day, Convert.ToInt32(MiltaryEndTime.Split(':')[0]), Convert.ToInt32(MiltaryEndTime.Split(':')[1]), 0);
string[] TimeDuration = EventDuration.Split(':');
double AllMinutes = TimeSpan.Parse(EventDuration).TotalMinutes;
Duration = TimeSpan.Parse(EventDuration);
Split = Convert.ToInt32(eventSplit);
if (PreDeadlineFlag)
{
PreDeadline = new TimeSpan(((int)AllMinutes % 10) * 60);
}
else
{
PreDeadline = new TimeSpan(ConvertToMinutes(PreDeadlineTime) * 60 * 10000000);
}
if (DefaultPrepTimeflag)
{
#if (SetDefaultPreptimeToZero)
PrepTime = new TimeSpan(0);
#else
PrepTime = new TimeSpan((long)((15 * 60)*10000000));
#endif
}
else
{
//uint MyNumber = Convert.ToInt32(eventPrepTime);
PrepTime = new TimeSpan((long)ConvertToMinutes(eventPrepTime) * 60 * 10000000);
}
Rigid = RigidScheduleFlag;
Repeat = EventRepetition;
}
//this function of repetition, is responsible for populating the repetition object in the passed CalendarEvent.
public void PopulateRepetitionParameters(CalendarEvent MyParentEvent)
{
if (!MyParentEvent.Repeat.Enable)//Checks if Repetition object is enabled or disabled. If Disabled then just return else continue
{
return;
}
RepetitionRange = MyParentEvent.Repeat.Range;
RepetitionFrequency = MyParentEvent.Repeat.Frequency;
EnableRepeat = true;
DateTime EachRepeatCalendarStart = initializingRange.Start;//Start DateTime Object for each recurring Calendar Event
DateTime EachRepeatCalendarEnd = initializingRange.End;//End DateTime Object for each recurring Calendar Event
EventID MyEventCalendarID = new EventID(MyParentEvent.ID + "_" + EventIDGenerator.generate().ToString());
CalendarEvent MyRepeatCalendarEvent = new CalendarEvent(MyEventCalendarID, MyParentEvent.Name, MyParentEvent.ActiveDuration, EachRepeatCalendarStart, EachRepeatCalendarEnd, MyParentEvent.Preparation, MyParentEvent.PreDeadline, MyParentEvent.Rigid, new Repetition(), MyParentEvent.Rigid ? 1 : MyParentEvent.NumberOfSplit, MyParentEvent.myLocation, MyParentEvent.isEnabled, MyParentEvent.UIParam, MyParentEvent.Notes, MyParentEvent.isComplete);
List<CalendarEvent> MyArrayOfRepeatingCalendarEvents = new List<CalendarEvent>();
for (; MyRepeatCalendarEvent.Start < MyParentEvent.Repeat.Range.End; )
{
MyArrayOfRepeatingCalendarEvents.Add(MyRepeatCalendarEvent);
DictionaryOfIDAndCalendarEvents.Add(MyRepeatCalendarEvent.ID, MyRepeatCalendarEvent);
EachRepeatCalendarStart = IncreaseByFrequency(EachRepeatCalendarStart, Frequency); ;
EachRepeatCalendarEnd = IncreaseByFrequency(EachRepeatCalendarEnd, Frequency);
MyEventCalendarID = new EventID(MyParentEvent.ID + "_" + EventIDGenerator.generate().ToString());
MyRepeatCalendarEvent = new CalendarEvent(MyEventCalendarID, MyRepeatCalendarEvent.Name, MyRepeatCalendarEvent.ActiveDuration, EachRepeatCalendarStart, EachRepeatCalendarEnd, MyRepeatCalendarEvent.Preparation, MyRepeatCalendarEvent.PreDeadline, MyRepeatCalendarEvent.Rigid, MyRepeatCalendarEvent.Repeat, MyRepeatCalendarEvent.NumberOfSplit, MyParentEvent.myLocation, MyParentEvent.isEnabled, MyParentEvent.UIParam, MyParentEvent.Notes, MyParentEvent.isComplete);
if (MyParentEvent.myLocation == null)
{
MessageBox.Show("weird error Jeromes");
}
MyRepeatCalendarEvent.myLocation = MyParentEvent.myLocation;
}
RepeatingEvents = DictionaryOfIDAndCalendarEvents.Values.ToArray();
}
//CalendarEvent Methods
public SubCalendarEvent getSubEvent(EventID SubEventID)
{
int i = 0;
if (Repeat.Enable)
{
foreach (CalendarEvent MyCalendarEvent in EventRepetition.RecurringCalendarEvents)
{
SubCalendarEvent MySubEvent = MyCalendarEvent.getSubEvent(SubEventID);
if (MySubEvent != null)
{
return MySubEvent;
}
}
}
for (; i < ArrayOfSubEvents.Length; i++)
{
if (SubEventID.ToString() == ArrayOfSubEvents[i].ID)
{
return ArrayOfSubEvents[i];
}
}
return null;
}
Dictionary<CalendarEvent, List<SubCalendarEvent>> generateDictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents(List<SubCalendarEvent> ListOfInterferringElements, List<CalendarEvent> UncommitedCalendarEvents)
{
/*
Name:Function takes the list of interferring arrays and used to build a Calendar To "List of SubCalendarEvent" dictionary.
*/
int i = 0;
Dictionary<CalendarEvent, List<SubCalendarEvent>> DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents = new Dictionary<CalendarEvent, List<SubCalendarEvent>>();
int j = 0;
for (; i < ListOfInterferringElements.Count; i++)
{
EventID MyEventID = new EventID(ListOfInterferringElements[i].ID);
string ParentID = MyEventID.getLevelID(0);//This gets the parentID of the SubCalendarEventID
CalendarEvent UncomittedCalendar=CheckUncommitedForSubCalevent(UncommitedCalendarEvents,ListOfInterferringElements[i]);
if (UncomittedCalendar!=null)
{
if (DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.ContainsKey(UncomittedCalendar))
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[UncomittedCalendar].Add(ListOfInterferringElements[i]);
j++;
}
else
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(UncomittedCalendar, new List<SubCalendarEvent>());
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[UncomittedCalendar].Add(ListOfInterferringElements[i]);
j++;
}
}
else
{
if (AllEventDictionary[ParentID].RepetitionStatus)
{
CalendarEvent repeatCalEvent = AllEventDictionary[ParentID].getRepeatedCalendarEvent(MyEventID.getStringIDAtLevel(1));
if (DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.ContainsKey(repeatCalEvent))
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[repeatCalEvent].Add(ListOfInterferringElements[i]);
j++;
}
else
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(repeatCalEvent, new List<SubCalendarEvent>());
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[repeatCalEvent].Add(ListOfInterferringElements[i]);
j++;
}
}
else
{
CalendarEvent nonRepeatCalEvent = AllEventDictionary[ParentID];
if (DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.ContainsKey(nonRepeatCalEvent))
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[nonRepeatCalEvent].Add(ListOfInterferringElements[i]);
j++;
}
else
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents.Add(nonRepeatCalEvent, new List<SubCalendarEvent>());
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[nonRepeatCalEvent].Add(ListOfInterferringElements[i]);
j++;
}
}
}
/*catch (Exception e)
{
if (AllEventDictionary[ParentID].RepetitionStatus)
{
}
else
{
DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents[AllEventDictionary[ParentID]].Add(ListOfInterferringElements[i]);
}
}*/
}
return DictionaryWithBothCalendarEventIDAndListOfInterferringSubEvents;
}
public CalendarEvent(CalendarEvent MyUpdated, SubCalendarEvent[] MySubEvents)
{
CalendarEventName = MyUpdated.Name;
StartDateTime = MyUpdated.StartDateTime;
EndDateTime = MyUpdated.End;
EventSequence = new TimeLine(StartDateTime, EndDateTime);
EventDuration = MyUpdated.ActiveDuration;
Splits = MyUpdated.Splits;
PrepTime = MyUpdated.PrepTime;
EventPreDeadline = MyUpdated.PreDeadline;
RigidSchedule = MyUpdated.Rigid;
TimePerSplit = MyUpdated.TimePerSplit;
ArrayOfSubEvents = new SubCalendarEvent[Splits];
if (MyUpdated.ID != null)
{
CalendarEventID = new EventID(MyUpdated.ID.Split('_'));
}
//CalendarEventID = new EventID(new string[] { EventIDGenerator.generate().ToString() });
//ArrayOfSubEvents = generateSubEvent(ArrayOfSubEvents, 4, EventDuration, CalendarEventID.ToString());
ArrayOfSubEvents = MySubEvents;
SchedulStatus = false;
EventRepetition = MyUpdated.Repeat;
LocationData = MyUpdated.LocationData;
UpdateLocationMatrix(LocationData);
EventSequence = new TimeLine(StartDateTime, EndDateTime);
//EventRepetition = new Repetition(EventRepetition.Enable, this, EventRepetition.Range, EventRepetition.Frequency);
}
public virtual void UpdateThis(CalendarEvent CalendarEventEntry)
{
if ((this.ID == CalendarEventEntry.ID))
{
EventDuration=CalendarEventEntry.ActiveDuration;
CalendarEventName=CalendarEventEntry.Name;
StartDateTime=CalendarEventEntry.StartDateTime;
EndDateTime=CalendarEventEntry.EndDateTime;
EventPreDeadline=CalendarEventEntry.PreDeadline;
PrepTime=CalendarEventEntry.PrepTime;
Priority=CalendarEventEntry.Priority;
RepetitionFlag=CalendarEventEntry.RepetitionFlag;
EventRepetition=CalendarEventEntry.EventRepetition;
Complete = CalendarEventEntry.Complete;
RigidSchedule = CalendarEventEntry.RigidSchedule;
Splits=CalendarEventEntry.Splits;
TimePerSplit=CalendarEventEntry.TimePerSplit;
CalendarEventID=CalendarEventEntry.CalendarEventID;
EventSequence=CalendarEventEntry.EventSequence;;
SubEvents=CalendarEventEntry.SubEvents;
SchedulStatus=CalendarEventEntry.SchedulStatus;
CalendarError = CalendarEventEntry.CalendarError;
Enabled=CalendarEventEntry.Enabled;
UiParams=CalendarEventEntry.UiParams;
DataBlob=CalendarEventEntry.DataBlob;
LocationData =CalendarEventEntry.LocationData;
otherPartyID = CalendarEventEntry.otherPartyID;
return;
}
throw new Exception("Invalid Calendar ID used in Update Calendar Event");
}
