internal IFacadeUpdateResult <ScheduleEventData> SaveScheduleEvent(ScheduleEventDto dto)
{
ArgumentValidator.IsNotNull("dto", dto);
FacadeUpdateResult <ScheduleEventData> result = new FacadeUpdateResult <ScheduleEventData>();
IScheduleEventService service = UnitOfWork.GetService <IScheduleEventService>();
ScheduleEvent instance = RetrieveOrNew <ScheduleEventData, ScheduleEvent, IScheduleEventService>(result.ValidationResult, dto.Id);
if (result.IsSuccessful)
{
instance.Name = dto.Name;
instance.ScheduledTime = dto.ScheduledTime;
instance.ObjectId = dto.ObjectId;
instance.ObjectTypeId = dto.ObjectTypeId;
instance.ReccuringTypeId = dto.ReccuringTypeId;
instance.StartDate = dto.StartDate;
instance.EndDate = dto.EndDate;
var saveQuery = service.Save(instance);
result.AttachResult(instance.RetrieveData <ScheduleEventData>());
result.Merge(saveQuery);
}
return(result);
}
public static ScheduleEvent CheckScheuleEvent(string text)
{
ScheduleEvent temp = ScheduleEvent.None;
switch (text)
{
case INST_Schedule_None:
temp = ScheduleEvent.None;
break;
case INST_Schedule_DiscountFoodStore:
temp = ScheduleEvent.DiscountFoodStore;
break;
case INST_Schedule_ClothingFestival101:
temp = ScheduleEvent.ClothingFestival101;
break;
case INST_Schedule_ClothingFestival202:
temp = ScheduleEvent.ClothingFestival202;
break;
case INST_Schedule_ClothingFestival303:
temp = ScheduleEvent.ClothingFestival303;
break;
case INST_Schedule_ClothingFestival404:
temp = ScheduleEvent.ClothingFestival404;
break;
case INST_Schedule_Project:
temp = ScheduleEvent.Project;
break;
case INST_Schedule_Class:
temp = ScheduleEvent.Class;
break;
case INST_Schedule_MysticFestival1st:
temp = ScheduleEvent.MysticFestival1st;
break;
case INST_Schedule_MysticFestival2nd:
temp = ScheduleEvent.MysticFestival2nd;
break;
case INST_Schedule_MysticFestival3rd:
temp = ScheduleEvent.MysticFestival3rd;
break;
case INST_Schedule_MysticFestival4th:
temp = ScheduleEvent.MysticFestival4th;
break;
case INST_Schedule_Birthday:
temp = ScheduleEvent.Birthday;
break;
}
return(temp);
}
/// <summary>
/// Maps the event definition into the the schedule view model.
/// </summary>
/// <param name="eventDefinition"></param>
/// <returns></returns>
public ScheduleViewModel Map(EventDefinition eventDefinition)
{
var times = GetTimes(eventDefinition);
List <ScheduleSession> scheduleSessions =
eventDefinition
.Sessions.Select(s =>
new ScheduleSession
{
SessionId = s.SessionId,
Title = s.Title,
StartTime = DateTime.SpecifyKind(s.StartTime, DateTimeKind.Utc),
Duration = s.Duration,
RoomNumber = s.RoomNumber,
Speaker = s.Speaker
}).ToList();
var scheduleEvent = new ScheduleEvent
{
EventDefinitionId = eventDefinition.EventDefinitionId,
Rooms = eventDefinition.RoomNumber,
Sessions = scheduleSessions
};
var viewModel = new ScheduleViewModel
{
EventDefinition = scheduleEvent,
Times = times
};
return(viewModel);
}
/// <summary>
/// Construct a passive data structure to hold chart information
/// </summary>
/// <param name="row"></param>
/// <param name="dateTime"></param>
/// <param name="task"></param>
public ChartInfo(int row, DateTime dateTime, ScheduleEvent task)
: this()
{
Row = row;
DateTime = dateTime;
Task = task;
}
public async Task <IActionResult> OnPostScheduleAsync()
{
AddScheduleEvent ASSE = new AddScheduleEvent();
ScheduleEvent SE = new ScheduleEvent();
SE.Ended = false;
SE.GameID = 1;
SE.MinutesToAddOnTrigger = int.Parse(Request.Form["MinutesToAddOnTrigger"]);
SE.NextTrigger = DateTime.Parse(Request.Form["NextTrigger"].ToString());
SE.Notes = Request.Form["Notes"];
SE.NumberOfTimesToTrigger = int.Parse(Request.Form["NumberOfTimesToTrigger"]);
SE.NumberOfTimesTriggered = 0;
SE.ScheduelID = int.Parse(Request.Form["ScheduleID"]);
ASSE.SE = SE;
ASSE.ChangeEvents = Request.Form["IDList"];
HttpResponseMessage PostResponse = await DS.PostAsync(ASSE, "bot/AddScheduleEvent");
string content = await PostResponse.Content.ReadAsStringAsync();
SimpleResponse SR = JsonConvert.DeserializeObject <SimpleResponse>(content);
string response = await DS.GetAsync("bot/GetInfoForScheduleEventAdd");
ASEP = JsonConvert.DeserializeObject <AddSchedulEventPrep>(response);
return(Page());
}
private void ScheduleLoad(int uID)
{
try
{
DBA db = DBA.Instance;
db.connect();
var con = db.getConnection();
con.Open();
string query = "SELECT * FROM schedule WHERE user_id = " + uID + "ORDER BY startH ASC";
using (SqlCommand cmd = new SqlCommand(query, con))
{
using (SqlDataReader r = cmd.ExecuteReader())
{
while (r.Read())
{
int cID = r.GetInt32(2);
string day = r.GetString(4);
string title = r.GetString(3) + " " + r.GetString(8);
string start = r.GetInt32(5).ToString() + ":00";
string end = r.GetInt32(6).ToString() + ":00";
ScheduleEvent block = new ScheduleEvent(r.GetInt32(1), r.GetInt32(2), r.GetString(3), r.GetString(4), r.GetInt32(5), r.GetInt32(6), r.GetInt32(7), r.GetString(8));
putInSchedule(block.Day, block.Class_name, block.Course_name, block.Start, block.End);
}
}
}
}
catch (SqlException ex)
{
MessageBox.Show(ex.Message, "SQL Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public Form1()
{
InitializeComponent();
schedulerControl1.Init(projectManager);
projectManager.Start = DateTime.Now.AddDays(-3);
var task = new ScheduleEvent(1)
{
Name = "Hello", Slack = TimeSpan.FromDays(0.5)
};
projectManager.Add(task);
projectManager.SetStart(task, DateTime.Now.AddDays(3));
projectManager.SetEnd(task, DateTime.Now.AddDays(5));
var task2 = new ScheduleEvent(0)
{
Name = "Hello"
};
projectManager.Add(task2);
projectManager.SetStart(task2, DateTime.Now.AddDays(3));
projectManager.SetEnd(task2, DateTime.Now.AddDays(5));
var task3 = new ScheduleEvent(0)
{
Name = "Hello"
};
projectManager.Add(task3);
projectManager.SetStart(task3, DateTime.Now.AddDays(6));
projectManager.SetEnd(task3, DateTime.Now.AddDays(7));
}
public static void CopyValidEvents(Schedule schedule, ScheduleEventCollection eventList, string postfix)
{
if (eventList.Count == 0) return;
ScheduleEventCollection newEventsList = new ScheduleEventCollection();
foreach (ScheduleEvent srcEvent in eventList)
{
StringBuilder sb = new StringBuilder();
sb.Append(DescriptionHeaderName);
sb.AppendLine(Resources.CrossSyncDescription);
if (!string.IsNullOrEmpty(srcEvent.Description))
{
sb.AppendLine();
sb.Append(srcEvent.Description);
}
ScheduleEvent newEvent = new ScheduleEvent();
newEvent.EventType = srcEvent.IsBanner ? ScheduleEventType.Banner : ScheduleEventType.Normal;
newEvent.PublicType = srcEvent.IsPublic ? SchedulePublicType.Public : SchedulePublicType.Private;
newEvent.Start = srcEvent.Start;
newEvent.End = srcEvent.End;
newEvent.AllDay = srcEvent.AllDay;
newEvent.StartOnly = srcEvent.StartOnly;
newEvent.Plan = srcEvent.Plan;
newEvent.Detail = srcEvent.Detail + postfix;
newEvent.Description = sb.ToString();
newEvent.UserIds.Add(schedule.App.UserId);
newEventsList.Add(newEvent);
}
if (newEventsList.Count == 0) return;
schedule.AddEvents(newEventsList);
}
/// <summary>
/// Asynchronously Create ScheduleEvents.
/// </summary>
/// <remarks>
/// Add a single schedule event.
/// </remarks>
/// <param name="scheduleEvent">
/// The <see cref="ScheduleEvent"/> object to be created.
/// </param>
/// <returns>
/// The <see cref="ScheduleEvent"/> object that was created, along with
/// an output instance of the <see cref="ResultsMeta"/> class containing additional data.
/// </returns>
public async Task <(ScheduleEvent, ResultsMeta)> CreateScheduleEventAsync(
ScheduleEvent scheduleEvent)
{
(IList <ScheduleEvent> scheduleEvents, ResultsMeta resultsMeta) = await CreateScheduleEventsAsync(new[] { scheduleEvent }, default).ConfigureAwait(false);
return(scheduleEvents.FirstOrDefault(), resultsMeta);
}
protected void SaveClicked(object o, EventArgs e)
{
if (!SecurityContextManager.Current.CurrentURL.Contains("New"))
{
var se = new ScheduleEventServices().GetByID(((ScheduleEvent)SecurityContextManager.Current.CurrentItem.ItemReference).ID);
se.Description = tbDescription.Text;
se.EventTypeID = Convert.ToInt16(ddlEventType.SelectedValue);
se.IsActive = cbIsActive.Checked;
se.Name = tbName.Text;
se.StaffID = Convert.ToInt16(ddlStaff.SelectedValue);
new ScheduleEventServices().Save(se);
Response.Redirect("/Schedules/" + se.ID.ToString());
}
else
{
var se = new ScheduleEvent();
se.Description = tbDescription.Text;
se.EventTypeID = Convert.ToInt16(ddlEventType.SelectedValue);
se.IsActive = cbIsActive.Checked;
se.Name = tbName.Text;
se.StaffID = Convert.ToInt16(ddlStaff.SelectedValue);
new ScheduleEventServices().Save(se);
}
LoadEvent();
}
public static void UnsetNotModified(ScheduleEventCollection srcEventList, ScheduleEventCollection origEventList, ScheduleEventCollection destEventList, string postfix)
{
for (int i = srcEventList.Count - 1; i >= 0; i--)
{
ScheduleEvent srcEvent = srcEventList[i];
bool fromDest = false;
ScheduleEvent destEvent = FindPairdEvent(srcEvent, origEventList, string.Empty);
if (destEvent == null)
{
destEvent = FindPairdEvent(srcEvent, destEventList, postfix);
fromDest = true;
}
if (destEvent == null)
{
continue;
}
srcEventList.Remove(srcEvent);
if (fromDest)
{
destEventList.Remove(destEvent);
}
else
{
origEventList.Remove(destEvent);
}
}
}
public void AdvanceTime(TimeSpan delta)
{
_timeNow += delta.Ticks;
while (_heap.Count > 0 && _heap.Peek().EndTime <= _timeNow)
{
ScheduleEvent scheduleEvent = _heap.ExtractMin();
_lookup.Remove(scheduleEvent.Id);
if (!scheduleEvent.Cancelled)
{
scheduleEvent.Callback(scheduleEvent.Id, scheduleEvent.State);
if (!scheduleEvent.Cancelled)
{
scheduleEvent.Cancelled = !scheduleEvent.Repeat;
if (scheduleEvent.Repeat)
{
_repeat.Add(scheduleEvent);
}
}
}
if (scheduleEvent.Cancelled)
{
_pool.Release(scheduleEvent);
}
}
_repeat.ForEach(delegate(ScheduleEvent s)
{
s.StartTime = _timeNow;
_heap.Add(s);
_lookup.Add(s.Id, s);
});
_repeat.Clear();
}
public static void Initialize(ScheduleDataContext context)
{
context.Database.EnsureCreated();
// Look for any students.
if (context.ScheduleEvents.Any())
{
return; // DB has been seeded
}
var appointments = new ScheduleEvent[]
{
new ScheduleEvent {
Id = 1, Subject = "Meeting", StartTime = new DateTime(2018, 3, 27, 10, 00, 00), EndTime = new DateTime(2018, 3, 27, 11, 00, 00), StartTimezone = "", EndTimezone = "", IsAllDay = false, Description = "", Location = "", RecurrenceID = "10", RecurrenceRule = "FREQ=DAILY;INTERVAL=1;COUNT=5"
},
new ScheduleEvent {
Id = 2, Subject = "Client Demo", StartTime = new DateTime(2018, 3, 28, 10, 00, 00), EndTime = new DateTime(2018, 3, 28, 11, 00, 00), StartTimezone = "", EndTimezone = "", IsAllDay = false, Description = "", Location = ""
},
};
foreach (ScheduleEvent app in appointments)
{
context.ScheduleEvents.Add(app);
}
context.SaveChanges();
}
/// <summary>
/// 播放指定定时器
/// </summary>
/// <param name="scheduleEvent">Schedule event.</param>
public void Play(ScheduleEvent scheduleEvent)
{
if (scheduleEvent != null)
{
scheduleEvent.Play();
}
}
/// <summary>
/// 暂停指定定时器
/// </summary>
/// <param name="scheduleEvent">Schedule event.</param>
public void Pause(ScheduleEvent scheduleEvent)
{
if (scheduleEvent != null)
{
scheduleEvent.Pause();
}
}
public JsonResult Delete(ScheduleEvent value)
{
//if (value.ApprovedActivity != true)
{
var activity = new ScheduleEvent {
SheduleID = value.SheduleID
};
db.ScheduleEvents.Attach(activity);
db.ScheduleEvents.Remove(activity);
//db.SaveChanges();
}
try
{
db.SaveChanges();
}
catch (DbEntityValidationException e)
{
foreach (var eve in e.EntityValidationErrors)
{
Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
eve.Entry.Entity.GetType().Name, eve.Entry.State);
foreach (var ve in eve.ValidationErrors)
{
Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
ve.PropertyName, ve.ErrorMessage);
}
}
throw;
}
IEnumerable data = new mascisEntities().ScheduleEvents;
return(Json(data, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 停止某个事件
/// </summary>
/// <param name="scheduleEvent">Schedule event.</param>
public void UnSchedule(ScheduleEvent scheduleEvent)
{
if (scheduleEvent != null)
{
scheduleEvent.Stop();
m_willRemove.Add(scheduleEvent);
}
}
public void Create(ScheduleEvent entity)
{
using (MQuinceDbContext _context = new MQuinceDbContext(_dbContext))
{
_context.ScheduleEvents.Add(EventMapper.MapScheduleEventEntityToScheduleEventPersistence(entity));
_context.SaveChanges();
}
}
public Game(ScheduleEvent e)
{
League = e.LeagueCode;
Round = e.Round;
GameDate = e.GameDate;
HomeTeam = e.HomeTeam;
AwayTeam = e.AwayTeam;
}
/// <summary>
/// Update ScheduleEvents.
/// </summary>
/// <remarks>
/// Edit a single schedule event.
/// </remarks>
/// <param name="scheduleEvent">
/// The <see cref="ScheduleEvent"/> object to be updated.
/// </param>
/// <returns>
/// The <see cref="ScheduleEvent"/> object that was updated, along with
/// an output instance of the <see cref="ResultsMeta"/> class containing additional data.
/// </returns>
public (ScheduleEvent, ResultsMeta) UpdateScheduleEvent(
ScheduleEvent scheduleEvent)
{
(IList <ScheduleEvent> scheduleEvents, ResultsMeta resultsMeta) =
UpdateScheduleEvents(new[] { scheduleEvent });
return(scheduleEvents.FirstOrDefault(), resultsMeta);
}
public ActionResult DeleteConfirmed(int id)
{
ScheduleEvent scheduleEvent = db.ScheduleEvents.Find(id);
db.ScheduleEvents.Remove(scheduleEvent);
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// The Following method is used to display all the usercontrol tabs
/// in a list form using switch case that changes when the user click on a different
/// usercontrol button.
/// written by author : Abdelrahman Ahmed
/// ref: https://docs.microsoft.com/en-us/dotnet/api/system.windows.controls.selectionchangedeventargs?view=netframework-4.7.2
/// using selection event changer with children to add new tab and clear the previous one.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MenuSelector_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
UserControl tab = null;
EventCenter.Children.Clear();
switch (((ListViewItem)((ListView)sender).SelectedItem).Name)
{
case "Dashboard":
tab = new DashboardEvent();
EventCenter.Children.Add(tab);
break;
case "Storage":
tab = new StorageEvent();
EventCenter.Children.Add(tab);
break;
case "Crops":
tab = new CropsEvent();
EventCenter.Children.Add(tab);
break;
case "Delivery":
tab = new DeliveryEvent();
EventCenter.Children.Add(tab);
break;
case "Timetable":
tab = new TimetableEvent();
EventCenter.Children.Add(tab);
break;
case "Employees":
tab = new EmployeeEvent();
EventCenter.Children.Add(tab);
break;
case "Schedule":
tab = new ScheduleEvent();
EventCenter.Children.Add(tab);
break;
case "Sales":
tab = new SalesEvent();
EventCenter.Children.Add(tab);
break;
case "Users":
tab = new UserEvent();
EventCenter.Children.Add(tab);
break;
default:
break;
}
}
private Color GetColorBySchedule(ScheduleEvent scheduleEvent)
{
Color color = Color.white;
switch (scheduleEvent)
{
case ScheduleEvent.Project:
color = _classActicityColor;
break;
case ScheduleEvent.Class:
color = _classActicityColor;
break;
case ScheduleEvent.Birthday:
color = _birthDayColor;
break;
case ScheduleEvent.ClothingFestival101:
color = _clothingColor;
break;
case ScheduleEvent.ClothingFestival202:
color = _clothingColor;
break;
case ScheduleEvent.ClothingFestival303:
color = _clothingColor;
break;
case ScheduleEvent.ClothingFestival404:
color = _clothingColor;
break;
case ScheduleEvent.DiscountFoodStore:
color = _foodColor;
break;
case ScheduleEvent.MysticFestival1st:
color = _mysticColor;
break;
case ScheduleEvent.MysticFestival2nd:
color = _mysticColor;
break;
case ScheduleEvent.MysticFestival3rd:
color = _mysticColor;
break;
case ScheduleEvent.MysticFestival4th:
color = _mysticColor;
break;
}
return(color);
}
private void DrawScheduleEvent(Graphics graphics, TaskPaintEventArgs e, ScheduleEvent task, RectangleF taskRect)
{
var fill = taskRect;
fill.Width = (int)(fill.Width * 1);
graphics.FillRectangle(e.Format.BackFill, taskRect);
graphics.FillRectangle(e.Format.ForeFill, fill);
graphics.DrawRectangle(e.Format.Border, taskRect);
}
public async Task <IActionResult> DeleteScheduleEvent([FromBody] ScheduleEventView view)
{
ScheduleEventModule invMod = new ScheduleEventModule();
ScheduleEvent scheduleEvent = await invMod.ScheduleEvent.Query().MapToEntity(view);
invMod.ScheduleEvent.DeleteScheduleEvent(scheduleEvent).Apply();
return(Ok(view));
}
/// <summary>
/// Asynchronously Update ScheduleEvents, with support for cancellation.
/// </summary>
/// <remarks>
/// Edit a single schedule event.
/// </remarks>
/// <param name="scheduleEvent">
/// The <see cref="ScheduleEvent"/> object to be updated.
/// </param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>
/// The <see cref="ScheduleEvent"/> object that was updated, along with
/// an output instance of the <see cref="ResultsMeta"/> class containing additional data.
/// </returns>
public async Task <(ScheduleEvent, ResultsMeta)> UpdateScheduleEventAsync(
ScheduleEvent scheduleEvent,
CancellationToken cancellationToken)
{
(IList <ScheduleEvent> scheduleEvents, ResultsMeta resultsMeta) =
await UpdateScheduleEventsAsync(new[] { scheduleEvent }, cancellationToken).ConfigureAwait(false);
return(scheduleEvents.FirstOrDefault(), resultsMeta);
}
public async Task <IHttpActionResult> NewEventAsync(string id, ScheduleEvent @event)
{
@event.id = -1;
Event updated = await _eventWriter.CreateAsync(Map(@event));
await Publish(_eventPublisher.OnCreatedAsync, updated);
return(Ok(Map(updated)));
}
public static Recording CreateFromScheduleEvent(ScheduleEvent scheduleEvent)
{
return(new Recording(
scheduleEvent.Id,
(string)scheduleEvent.GetExtendedProperty(CHANNEL_ID),
(string)scheduleEvent.GetExtendedProperty(TITLE),
scheduleEvent.StartTime.ToLocalTime(),
scheduleEvent.EndTime.ToLocalTime()
));
}
public ActionResult Edit([Bind(Include = "Id,Subject,Description,StartTime,EndTime,AllDay,Recurrence,RecurrenceRule,VenueCode,ParticipationInvitee,ParticipationAttendee,ExpectedOutput,Objective,ActivityClassificationId,OrganId,DirectorateId,SectorId,SourceOfFundingId,FundingTypeId,PublicHoliday,CostEstimates,MeetingType,Approved_By,Date_Approved,Added_By,Date_Added,City,ActivityImplemented,ActivityImplementedComment,ApprovedActivity,IsBlockAppointment,BlockForAll,ActivityForwarded,Organizer")] ScheduleEvent scheduleEvent)
{
if (ModelState.IsValid)
{
db.Entry(scheduleEvent).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(scheduleEvent));
}
public Store(Store_Template store_Template)
{
_storeContoller = StoreContoller.Instance;
_currentItemSet = new List <StoreItemSet>();
_definition = store_Template;
_isEvent = false;
_scheduleEvent = ScheduleEvent.None;
_currentStoreItemSetId = _definition.DefaultStoreItemId;
}
public static bool GetScheduleEventForTVProgramme(CommonEPG.TVProgramme tvp, ref ScheduleEvent matchingEvent, ref ScheduleRequest matchingRequest)
{
CommonEPG.TVService tvc = EPGManager.TVServiceWithIDOrNull(tvp.ServiceID);
if (tvc == null)
{
return(false);
}
return(GetScheduleEventAtExactTimeOnChannel(tvp.StartTimeDT(), tvc.Callsign, false, "", ref matchingEvent, ref matchingRequest));
}
public static ScheduleEvent FindPairdEvent(ScheduleEvent srcEvent, ScheduleEventCollection eventList, string postfix)
{
string detail = srcEvent.Detail + postfix;
foreach (ScheduleEvent scheduleEvent in eventList)
{
// compare event type
if ((srcEvent.IsBanner && !scheduleEvent.IsBanner) || (!srcEvent.IsBanner && scheduleEvent.IsBanner)) continue;
// compare start date and time
if (!srcEvent.Start.Equals(scheduleEvent.Start)) continue;
// compare start only flag
if (srcEvent.StartOnly)
{
if (!scheduleEvent.StartOnly) continue;
}
else
{
if (scheduleEvent.StartOnly) continue;
// compare end date and time
if (!srcEvent.End.Equals(scheduleEvent.End)) continue;
}
// compare plan
if (srcEvent.Plan != scheduleEvent.Plan) continue;
// compare detail
if (detail == scheduleEvent.Detail) return scheduleEvent;
}
return null;
}
private bool GetEvent(out ScheduleEvent _event)
{
_event = ScheduleEvent.eTerminate;
lock (m_EventsLock)
{
int nCount = m_Events.Count;
if (nCount == 0) return false;
_event = m_Events.Dequeue();
if (nCount == 1) m_hNotifyEvent.Reset();
}
return true;
}
private void AppendEvent(ScheduleEvent _event)
{
lock (m_EventsLock)
{
m_Events.Enqueue(_event);
m_hNotifyEvent.Set();
}
}
/// <summary>
/// Compares the schedule events for a reverse sort
/// </summary>
/// <param name="x">The first event.</param>
/// <param name="y">The second event.</param>
/// <returns></returns>
private static int CompareScheduleEvents(ScheduleEvent x, ScheduleEvent y)
{
if (x.StartTime > y.StartTime) return -1;
if (x.StartTime < y.StartTime) return 1;
return 0;
}
