public static void SyncEvents(Event pattern, IEnumerable<Event> events, EventList list, EventListManager manager)
{
Message message = Message.Parse(pattern, "event:sync");
var deleteContext = new SyncEventContext(pattern, events, list,
manager);
Dispatcher.Dispatch(message, deleteContext);
}
public static void CreateRecurrence(Event ev, Schedule schedule, Options options)
{
Message message = Message.Parse(ev,
"recurrence:" +
schedule.Recurrence.ToString().ToLower());
var context = new EventCommandContext(ev, schedule, options);
Dispatcher.Dispatch(message, context);
}
public static void UpdateEvent(Event evnt, Schedule schedule, Options options,
bool updateSeries)
{
if (RemoteSettings.Service != null)
{
RemoteSettings.Service.SaveEventInfo(evnt.ToXml(), schedule == null ? string.Empty : schedule.ToXml(), options.ToXml(),
updateSeries, RemoteSettings.ServiceCredentials);
CacheManager.ClearAllCaches();
}
else
{
CalendarActions.UpdateEvent(evnt, schedule, options, updateSeries);
}
}
public static void CreateEvent(Event ev, Schedule schedule, Options options)
{
if (RemoteSettings.Service != null)
{
RemoteSettings.Service.CreateEvent(ev.ToXml(),
schedule == null ? string.Empty : schedule.ToXml(),
options.ToXml(), RemoteSettings.ServiceCredentials);
CacheManager.ClearAllCaches();
}
else
{
CalendarActions.CreateEvent(ev, schedule, options);
}
}
private static void CreateEndUserTrainingEvents(EventListManager eventManager)
{
DateTime start = FindNextDayOfWeek(DateTime.Today, DeveloperDay);
var evt = new Event
{
Description = string.Empty, StartDate = Utilities.NormalizeDate(start),
EndDate = Utilities.NormalizeDate(start.AddMonths(2)), StartTime = "09:00",
EndTime = "17:00", Location = EndUserLocationDefault,
Title = EndUserDefaultTitle
};
var scheduler = new Schedule
{
DaysOfWeek = (Utils.DaysOfWeek.Monday | Utils.DaysOfWeek.Friday),
StartDate = Utilities.NormalizeDate(start),
EndDate = Utilities.NormalizeDate(start.AddMonths(2)),
Recurrence = Recurrence.Weekly,
Frequency = 1
};
var options = new Options
{
CalendarID = EndUserTrainingList,
ControlSettingsPath = DeveloperViewSettings,
SiteSettingsPath = DefaultModuleSettings
};
CalendarActions.CreateEvent(evt, scheduler, options);
}
protected virtual void RenderEventSection(HtmlTextWriter writer, Event ev, EventList evList, DateTime date,
string eventAttributes, string dotAttributes, string cssClassReadOnly,
string cssClassCanWrite, bool isUseBackgroundColor)
{
string title = (ev.Title == string.Empty) ? ev.Name : ev.Title;
string cssStyle = ((!ReadOnly && !ev.ReadOnly) || isUseBackgroundColor)
? buildRuntimeStyle(evList.TextColor, evList.BackgroundColor) : "";
writer.Write(
string.Format(
"<div id='{0}' {1} eventID='{0}' align='left' startTime='{2}' endTime='{3}' readonly='{4}' link='{5}' {6} class='{7}' startHour='{8}' isrecur='{9}'>",
ev.ID, cssStyle, ev.StartTime, ev.EndTime, ReadOnly ? true : ev.ReadOnly,
(LinkBehaviour == LinkBehaviour.Redirect) ? ev.Path : String.Empty, eventAttributes,
(ReadOnly || ev.ReadOnly) ? cssClassReadOnly : cssClassCanWrite, date.Hour, ev.IsRecurrentEvent ? "1" : "0"));
RenderDataBeforeEvent(writer, ev);
RenderEvent(writer, dotAttributes, ev, title, evList.EventEditIcon);
RenderDataAfterEvent(writer, ev);
writer.Write("</div>");
}
protected abstract void RenderDataBeforeEvent(HtmlTextWriter writer, Event ev);
protected override void RenderDataAfterEvent(HtmlTextWriter writer, Event ev)
{
if (ShowEventTime)
{
writer.Write(string.Format("<br/><span>{0}-{1}</span>",
Utilities.GetTime(ev.StartTime).ToString(Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortTimePattern),
Utilities.GetTime(ev.EndTime).ToString(Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortTimePattern)));
}
}
private static void addDaily(DateTime start, Event eventItem, Schedule schedule, EventList calendar)
{
if (eventItem == null || schedule == null || start > Utilities.StringToDate(schedule.EndDate) ||
schedule.Frequency == 0 || calendar == null)
{
return;
}
eventItem.StartDate = Utilities.NormalizeDate(start);
eventItem.EndDate = Utilities.NormalizeDate(start);
eventItem.ScheduleID = schedule.ID;
calendar.AddEvent(eventItem, StaticSettings.EventBranch);
addDaily(start.AddDays(schedule.Frequency), eventItem, schedule, calendar);
}
private static void addByDayOfWeek(DateTime start, Event eventItem, Schedule schedule, EventList calendar)
{
if ((schedule.DaysOfWeek & DaysCollection.Monday) == DaysCollection.Monday)
{
addEvent(eventItem, start, calendar, schedule);
}
if ((schedule.DaysOfWeek & DaysCollection.Tuesday) == DaysCollection.Tuesday)
{
addEvent(eventItem, start.AddDays(1), calendar, schedule);
}
if ((schedule.DaysOfWeek & DaysCollection.Wednesday) == DaysCollection.Wednesday)
{
addEvent(eventItem, start.AddDays(2), calendar, schedule);
}
if ((schedule.DaysOfWeek & DaysCollection.Thursday) == DaysCollection.Thursday)
{
addEvent(eventItem, start.AddDays(3), calendar, schedule);
}
if ((schedule.DaysOfWeek & DaysCollection.Friday) == DaysCollection.Friday)
{
addEvent(eventItem, start.AddDays(4), calendar, schedule);
}
if ((schedule.DaysOfWeek & DaysCollection.Saturday) == DaysCollection.Saturday)
{
addEvent(eventItem, start.AddDays(5), calendar, schedule);
}
if ((schedule.DaysOfWeek & DaysCollection.Sunday) == DaysCollection.Sunday)
{
addEvent(eventItem, start.AddDays(6), calendar, schedule);
}
}
public void UpdateEvent(Event evnt, Schedule schedule, string calendarID, bool updateSeries, BranchItem branchID)
{
if (evnt == null)
{
return;
}
EventList newCal = EventLists[calendarID];
EventList currentCal = GetCalendar(evnt);
if (updateSeries == false)
{
evnt.ScheduleID = string.Empty;
evnt.Save();
PublishUtil.Publishing(evnt.GetTargetItem(), true, false);
if (newCal != null && currentCal != null && currentCal.ID != newCal.ID)
{
currentCal.DeleteEvent(evnt);
newCal.AddEvent(evnt, branchID);
}
return;
}
if (schedule == null || schedule.IsNew || schedule.IsChanged)
{
DeleteEvent(evnt.ID, true, true);
CreateEvent(evnt, schedule, newCal, branchID);
return;
}
if (newCal != null && currentCal != null)
{
DeleteEvent(evnt.ID, true, true);
evnt.StartDate = schedule.StartDate;
evnt.EndDate = schedule.EndDate;
CreateEvent(evnt, schedule, newCal, branchID);
}
if (evnt.IsChanged != true)
{
return;
}
ItemLink[] links = Globals.LinkDatabase.GetReferences(schedule.GetTargetItem());
foreach (ItemLink link in links)
{
evnt.SaveToItem(link.GetSourceItem(), true);
}
}
public void MoveEvent(Event ev)
{
if (ev != null)
{
EventList currentCal = GetCalendar(ev);
if (currentCal != null)
{
currentCal.MoveEvent(ev);
}
}
}
public EventList GetCalendar(Event ev)
{
return GetCalendar(StaticSettings.EventSourceDatabase.GetItem(ev.ID));
}
public void CreateEvent(Event eventItem, Schedule schedule, EventList calendar, BranchItem branch)
{
if (eventItem == null || calendar == null)
{
return;
}
calendar.AddEvent(eventItem, branch);
if (schedule != null)
{
if (schedule.IsNew)
{
schedule.StartDate = eventItem.StartDate;
schedule.EndDate = eventItem.EndDate;
CreateSchedule(schedule);
}
switch (schedule.Recurrence)
{
case Recurrence.Daily:
addDaily(Utilities.StringToDate(schedule.StartDate), eventItem, schedule, calendar);
break;
case Recurrence.Weekly:
addWeekly(Utilities.FirstCalendarDay(Utilities.StringToDate(schedule.StartDate)), eventItem, schedule,
calendar);
break;
case Recurrence.Monthly:
addMonthly(Utilities.FirstMonthDay(Utilities.StringToDate(schedule.StartDate)), eventItem, schedule,
calendar);
break;
case Recurrence.Yearly:
addYearly(Utilities.FirstMonthDay(Utilities.StringToDate(schedule.StartDate)), eventItem, schedule,
calendar);
break;
default:
break;
}
}
}
public void MoveEvent(Event ev)
{
CalendarActions.MoveEvent(ev.ID, ev.StartDate);
}
public static void CreateEvent(Event ev, Schedule schedule, Options options)
{
CreateEvent(ev, schedule, options, null);
}
public static void CreateEvent(Event ev, Schedule schedule, Options options, BranchItem branch)
{
Message message = Message.Parse(ev, "event:create");
var calendarContext = new EventCommandContext(ev, schedule, options, branch);
Dispatcher.Dispatch(message, calendarContext);
}
private static void addEvent(Event eventItem, DateTime date, EventList calendar, Schedule schedule)
{
if (date > Utilities.StringToDate(schedule.EndDate))
{
return;
}
eventItem.StartDate = Utilities.NormalizeDate(date);
eventItem.EndDate = Utilities.NormalizeDate(date);
eventItem.ScheduleID = schedule.ID;
calendar.AddEvent(eventItem, StaticSettings.EventBranch);
}
public static void CreateSchedule(Event ev, Schedule schedule, Options options)
{
Message message = Message.Parse(ev, "schedule:create");
var context = new EventCommandContext(ev, schedule, options);
Dispatcher.Dispatch(message, context);
}
private static void addMonthly(DateTime start, Event eventItem, Schedule schedule, EventList calendar)
{
if (eventItem == null || schedule == null || start > Utilities.StringToDate(schedule.EndDate) ||
schedule.Frequency == 0 || calendar == null)
{
return;
}
switch (schedule.Sequence)
{
case Sequence.First:
case Sequence.Second:
case Sequence.Third:
case Sequence.Fourth:
addSequence(start, eventItem, schedule, calendar);
break;
case Sequence.Last:
DateTime tmp = start.AddMonths(1);
tmp = tmp.Subtract(TimeSpan.FromDays(1));
while (true)
{
if (string.Compare(tmp.DayOfWeek.ToString(), schedule.DaysOfWeek.ToString(), true) == 0)
{
addEvent(eventItem, tmp, calendar, schedule);
break;
}
else
{
tmp = tmp.Subtract(TimeSpan.FromDays(1));
}
}
break;
default:
break;
}
addMonthly(start.AddMonths(schedule.Frequency), eventItem, schedule, calendar);
}
public static void UpdateEvent(Event evnt, Schedule schedule, Options options, bool updateSeries)
{
var context = new UpdateCommandContext(evnt, schedule, options, updateSeries);
Message message = Message.Parse(evnt, "event:update");
Dispatcher.Dispatch(message, context);
}
private static void addSequence(DateTime start, Event eventItem, Schedule schedule, EventList calendar)
{
DateTime tmp = start;
while (true)
{
if (string.Compare(tmp.DayOfWeek.ToString(), schedule.DaysOfWeek.ToString(), true) == 0)
{
if (schedule.Sequence != Sequence.None && schedule.Sequence != Sequence.First)
{
tmp = tmp.AddDays(((int) schedule.Sequence)*7);
}
if (tmp >= Utilities.StringToDate(schedule.StartDate))
{
addEvent(eventItem, tmp, calendar, schedule);
}
break;
}
else
{
tmp = tmp.AddDays(1);
}
}
}
protected override void RenderDataBeforeEvent(HtmlTextWriter writer, Event ev)
{
}
private static void addWeekly(DateTime start, Event eventItem, Schedule schedule, EventList calendar)
{
if (eventItem == null || schedule == null || start > Utilities.StringToDate(schedule.EndDate) ||
schedule.Frequency == 0 || calendar == null)
{
return;
}
addByDayOfWeek(start, eventItem, schedule, calendar);
start = start.AddDays(schedule.Frequency*7);
addWeekly(start, eventItem, schedule, calendar);
}
protected virtual void RenderEvent(HtmlTextWriter writer, string onclientclick, Event ev, string title,
string dotImage)
{
if (ev.ReadOnly || ReadOnly)
{
RenderRecurrentEventPrefix(writer, ev);
writer.Write(
string.Format("<a class='textEvent' eventID='{0}' link='' {1}>{2}</a>", ev.ID,
ev.Path != string.Empty ? string.Format("href='{0}'", ev.Path) : onclientclick, title));
}
else
{
writer.Write(
string.Format(
"<img class='eventImage' src='{0}' style='background-color:inherit' readonly='true' eventID='{1}' {2} align='absmiddle' title='Click to edit' border='0' alt='' width='16px' height='16px' />",
dotImage, ev.ID, onclientclick));
RenderRecurrentEventPrefix(writer, ev);
writer.Write(title);
}
RenderRecurrentEventSuffix(writer, ev);
}
private static void addYearly(DateTime start, Event eventItem, Schedule schedule, EventList calendar)
{
if (eventItem == null || schedule == null || start > Utilities.StringToDate(schedule.EndDate) ||
schedule.Frequency == 0 || calendar == null)
{
return;
}
DateTime tmp = new DateTime(start.Year, (int) schedule.Month, schedule.Frequency);
if (tmp >= Utilities.StringToDate(schedule.StartDate) && tmp <= Utilities.StringToDate(schedule.EndDate))
{
addEvent(eventItem, tmp, calendar, schedule);
}
addYearly(start.AddYears(1), eventItem, schedule, calendar);
}
protected virtual void RenderRecurrentEventSuffix(HtmlTextWriter writer, Event ev)
{
if (ev.IsRecurrentEvent)
{
writer.Write(string.Format("<span class='recurrent'>{0}</span>", RecurrentEventSuffix));
}
}
public void CreateEvent(Event ev, Schedule schedule, Options options)
{
RemoteActionWrapper.CreateEvent(ev, schedule, options);
}
private static void NewEvent(EventDetails details, bool useOrdinalInformation, int pos)
{
var evt = new Event();
if (pos == -1)
{
pos = Math.Min(Math.Min(details.TitleCount, details.LocationCount),
details.DescriptionCount);
}
evt.Name = GetResourceString(details.Title,
useOrdinalInformation ? pos : details.TitleCount,
details.DefaultTitle, !useOrdinalInformation);
evt.Title = evt.Name;
evt.Location = GetResourceString(details.Location,
useOrdinalInformation ? pos : details.LocationCount,
details.DefaultLocation, !useOrdinalInformation);
evt.Description = GetResourceString(details.Description,
useOrdinalInformation ? pos : details.DescriptionCount,
details.DefaultDescription, !useOrdinalInformation);
evt.StartDate = Utilities.NormalizeDate(details.Date);
evt.EndDate = Utilities.NormalizeDate(details.Date);
evt.StartTime = details.StartTime;
evt.EndTime = details.EndTime;
details.List.CreateEvent(evt, details.Branch);
}
public void SaveEventInfo(Event evnt, Schedule schedule, bool updateSeries, Options options)
{
RemoteActionWrapper.UpdateEvent(evnt, schedule, options, updateSeries);
}
