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"); }