public void EditEvent(int id, ICalendarEvent newEventModel)
{
var entity = (SingleEvent)newEventModel.ToEntity();
entity.Id = id;
_singleEventRepository.UpdateSingleEvent(entity);
}
public void EditEventSeries(int id, ICalendarEvent newEventModel)
{
var entity = (EventSeries)newEventModel.ToEntity();
entity.Id = id;
_eventSeriesRepository.UpdateEventSeries(entity);
}
public void AddEvent(ICalendarEvent eventToAdd)
{
if (eventToAdd.CanShareTime)
shareableSchedulePolicy.TryAddToRepository(eventToAdd);
else
exclusiveSchedulePolicy.TryAddToRepository(eventToAdd);
}
public override bool Check(List <CalendarEvent> events, ICalendarEvent ce)
{
if (events.Count != 0)
{
DateTimeOffset end;
if (!ce.End.HasValue) // full day event
{
end = ce.Start.AddDays(1);
}
else
{
end = ce.End.Value;
}
bool overlapped = events.Exists(x => x.EventId != ce.EventId &&
(((DateTimeOffset.Compare(x.Start, ce.Start) >= 0 && DateTimeOffset.Compare(x.Start, end) < 0) ||
((x.End.HasValue && (DateTimeOffset.Compare(x.End.Value, ce.Start) > 0 && DateTimeOffset.Compare(x.End.Value, end) < 0)) ||
(!x.End.HasValue && (DateTimeOffset.Compare(x.Start.AddDays(1), ce.Start) > 0 && DateTimeOffset.Compare(x.Start.AddDays(1), end) < 0)))
) || (DateTimeOffset.Compare(x.Start, ce.Start) <= 0 && ((x.End.HasValue && DateTimeOffset.Compare(x.End.Value, end) >= 0) || (!x.End.HasValue && DateTimeOffset.Compare(x.Start.AddDays(1), end) >= 0)))
)
);
if (overlapped)
{
return(false);
}
}
return(base.Check(events, ce));
}
public ObservableCollection <ICalendarEvent> HasEventsOnDate(DateTime?date)
{
if (date == null)
{
return(null);
}
string ffamily = Device.RuntimePlatform == Device.iOS ? "FontAwesome5Free-Solid" : "FontAwesome5Solid.otf#Regular";
FontSizeConverter fsc = new FontSizeConverter();
//double fsize = (double)fsc.ConvertFromInvariantString("Micro");
double fsize = 6;
List <ICalendarEvent> allEvents = new List <ICalendarEvent>()
{
new CalendarEvent()
{
Symbol = FontAwesome.Stop, FontFamily = ffamily, Color = Xamarin.Forms.Color.Aqua, FontSize = fsize
},
new CalendarEvent()
{
Symbol = FontAwesome.Stop, FontFamily = ffamily, Color = Xamarin.Forms.Color.Bisque, FontSize = fsize
},
new CalendarEvent()
{
Symbol = FontAwesome.Stop, FontFamily = ffamily, Color = Xamarin.Forms.Color.Brown, FontSize = fsize
},
new CalendarEvent()
{
Symbol = FontAwesome.Stop, FontFamily = ffamily, Color = Xamarin.Forms.Color.Teal, FontSize = fsize
},
new CalendarEvent()
{
Symbol = FontAwesome.Stop, FontFamily = ffamily, Color = Xamarin.Forms.Color.Salmon, FontSize = fsize
},
new CalendarEvent()
{
Symbol = FontAwesome.Stop, FontFamily = ffamily, Color = Xamarin.Forms.Color.SeaGreen, FontSize = fsize
},
new CalendarEvent()
{
Symbol = FontAwesome.Stop, FontFamily = ffamily, Color = Xamarin.Forms.Color.Fuchsia, FontSize = fsize
}
};
Random random = new Random();
int num = random.Next(0, allEvents.Count);
ObservableCollection <ICalendarEvent> events = new ObservableCollection <ICalendarEvent>();
int maxEventsPerDay = 4;
int eventsToDisplay = num > maxEventsPerDay ? maxEventsPerDay : num;
ICalendarEvent currentEvent = null;
for (int n = 0; n < eventsToDisplay; n++)
{
int ndx = random.Next(0, allEvents.Count);
currentEvent = allEvents[ndx];
events.Add(currentEvent);
}
return(events);
}
public void TryAddToRepository(ICalendarEvent eventToAdd)
{
ICalendarEvent[] intersectingEvents = eventsRepository.GetEvents(eventToAdd.Schedule);
if (intersectingEvents.All(ie => ie.CanShareTime))
{
eventsRepository.AddEvent(eventToAdd);
}
}
public AddEventOutput(ICalendarEvent e)
{
var cEvent = (CalendarEvent)e;
EventId = cEvent.Id;
EventName = cEvent.Name;
EventDescription = cEvent.Description;
EventStartDate = cEvent.StartDate;
EventDuration = cEvent.Duration;
}
public void AddEvent(ICalendarEvent eventToAdd)
{
IList<ICalendarEvent> allEvents = GetEvents(DateSpan.Max).ToList();
allEvents.Add(eventToAdd);
using (Stream s = File.OpenWrite(fileName))
{
binaryFormatter.Serialize(s, allEvents.ToArray());
}
}
public ICalendarEvent AddEvent(ICalendarEvent calendarEvent)
{
if (this.events == null)
{
this.events = new List <ICalendarEvent>();
}
this.events.Add(calendarEvent);
return(calendarEvent);
}
// Ajoute un évènement à la liste correspondant à la date passée en paramêtre dans le dictionnaire
public static void AddEvent(ICalendarEvent calendarEvent, int date)
{
List<ICalendarEvent> result = null;
CalendarEvents.TryGetValue(date, out result);
// Si la date n'existe pas dans le dictionnaire, on ajoute la clé correspondante avec l'événement
if (result == null)
{
List<ICalendarEvent> calendarEventsNewList = new List<ICalendarEvent>();
calendarEventsNewList.Add(calendarEvent);
CalendarEvents.Add(date, calendarEventsNewList);
}
// Sinon, on ajoute l'évènement à la liste correspondant à la date dans le dictionnaire
else
{
result.Add(calendarEvent);
}
}
/// <summary>
/// Given a string representing the schedule, returns the length of the longest time interval (in minutes) that is not occupied.
/// Note: I would have named this class more descriptevly, but the final name was decided by the codility asssignment.
/// </summary>
/// <param name="S">The schedule.</param>
/// <returns></returns>
public static int solution(string S)
{
// create calendar event parser
const string MATCH_FORMAT = "^(?<day>.*?) (?<h1>.*?):(?<m1>.*?)-(?<h2>.*?):(?<m2>.*?)$";
var calendarParser = new CalendarEventParser <MeetingEvent>(MATCH_FORMAT);
// create schedule
var schedule = new Schedule();
foreach (var entry in S.Split(Environment.NewLine))
{
var meeting = calendarParser.Parse(entry);
schedule.Add(meeting);
}
// find highest break
var largestInterval = TimeSpan.Zero;
ICalendarEvent lastMeeting = null;
var counter = 0;
foreach (var calendarEvent in schedule.Events)
{
counter++;
// if first event, calculate duration between midnight and start time
if (lastMeeting == null)
{
largestInterval = calendarEvent.StartTime;
}
// if not first, calculate duration between last end time and current start time
else
{
var currentInterval = calendarEvent.StartTime - lastMeeting.EndTime;
largestInterval = currentInterval > largestInterval ? currentInterval : largestInterval;
}
// if last event, calculate duration between end time and midnight
if (counter == schedule.Events.Count)
{
var intervalToMidnight = TimeSpan.FromDays(DAYS_IN_WEEK) - calendarEvent.EndTime;
largestInterval = intervalToMidnight > largestInterval ? intervalToMidnight : largestInterval;
}
// store current event for next iteration
lastMeeting = calendarEvent;
}
return((int)largestInterval.TotalMinutes);
}
// Ajoute un évènement à la liste correspondant à la date passée en paramêtre dans le dictionnaire
public static void AddEvent(ICalendarEvent calendarEvent, int date)
{
List <ICalendarEvent> result = null;
CalendarEvents.TryGetValue(date, out result);
// Si la date n'existe pas dans le dictionnaire, on ajoute la clé correspondante avec l'événement
if (result == null)
{
List <ICalendarEvent> calendarEventsNewList = new List <ICalendarEvent>();
calendarEventsNewList.Add(calendarEvent);
CalendarEvents.Add(date, calendarEventsNewList);
}
// Sinon, on ajoute l'évènement à la liste correspondant à la date dans le dictionnaire
else
{
result.Add(calendarEvent);
}
}
public void Schedule(ICalendarEvent e, DateTime date)
{
if (!Timeline.ContainsKey(date))
{
Timeline[date] = new List <ICalendarEvent>();
if (date < StartDate)
{
StartDate = date;
}
}
e.Date = date;
Unscheduled.Remove(e);
if (!Timeline[date].Contains(e))
{
Timeline[date].Add(e);
}
AmbitionApp.SendMessage(e);
}
public void Schedule(ICalendarEvent e)
{
if (default(DateTime).Equals(e.Date))
{
Unscheduled.Add(e);
}
else
{
if (!Timeline.ContainsKey(e.Date))
{
Timeline[e.Date] = new List <ICalendarEvent>();
if (e.Date < StartDate)
{
StartDate = e.Date;
}
}
Timeline[e.Date].Add(e);
}
}
public static CalendarEventModel FromCalendarEvent([NotNull] ICalendarEvent ev)
{
if (ev == null)
{
throw new ArgumentNullException(nameof(ev));
}
return(new CalendarEventModel
{
Id = ev.Id,
Organizer = ev.Organizer,
Name = ev.Name,
Start = ev.From,
End = ev.To,
ChatWithOrganizerLink = ev.ChatInfo?.ChatWithOrganizerLink,
ChatMessage = ev.ChatInfo?.ChatMessage,
ChatHint = ev.ChatInfo?.ChatHint,
IsPrivate = ev.IsPrivate
});
}
/// <summary>
/// Saves the calendar event.
/// </summary>
/// <param name="calendarEvent">The calendar event.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">calendarEvent</exception>
public string SaveCalendarEvent(ICalendarEvent calendarEvent)
{
if (calendarEvent == null)
{
throw new ArgumentNullException(nameof(calendarEvent));
}
var result = string.Empty;
var record = new CalendarEvent
{
Subject = calendarEvent.Subject,
Start = calendarEvent.Start,
End = calendarEvent.End,
IsFullDay = calendarEvent.IsFullDay,
ThemeColor = calendarEvent.ThemeColor
};
try
{
using (
var dbContext = (HRMSEntities)this.dbContextFactory.GetDbContext(ObjectContextType.HRMS))
{
dbContext.CalendarEvents.Add(record);
dbContext.SaveChanges();
}
}
catch (Exception e)
{
var a = e;
result = string.Format("Save Calendar Event - {0} , {1}", e.Message,
e.InnerException != null ? e.InnerException.Message : "");
}
return(result);
}
public void TryAddToRepository(ICalendarEvent calendarEvent)
{
eventsRepository.AddEvent(calendarEvent);
}
/// <summary>
/// Copy all common properties from one event to another.
/// </summary>
/// <param name="copyFrom"></param>
/// <param name="copyTo"></param>
private void CopyCommonCalendarEventProperties(ICalendarEvent copyFrom, ICalendarEvent copyTo)
{
// Remove and re-add attendees
copyTo.ReplaceRequiredAttendees(copyFrom.RequiredAttendees);
copyTo.ReplaceOptionalAttendees(copyFrom.OptionalAttendees);
// Common properties
copyTo.Description = copyFrom.Description;
copyTo.End = copyFrom.End;
copyTo.IsAllDayEvent = copyFrom.IsAllDayEvent;
copyTo.Location = copyFrom.Location;
copyTo.Organizer = copyFrom.Organizer;
copyTo.RecurrenceId = copyFrom.RecurrenceId;
copyTo.Start = copyFrom.Start;
copyTo.Subject = copyFrom.Subject;
copyTo.UID = copyFrom.UID;
// Update the sequence number
copyTo.Sequence++;
}
/// <summary>
/// See if all of the common properties between two calendars are equal.
/// </summary>
/// <param name="calendarEvent1"></param>
/// <param name="calendarEvent2"></param>
private bool AreCommonCalendarEventPropertiesEqual(ICalendarEvent calendarEvent1, ICalendarEvent calendarEvent2)
{
return calendarEvent1.IsAllDayEvent == calendarEvent2.IsAllDayEvent
&& calendarEvent1.RequiredAttendees.Except(calendarEvent2.RequiredAttendees).Any()
&& calendarEvent2.RequiredAttendees.Except(calendarEvent1.RequiredAttendees).Any()
&& calendarEvent1.OptionalAttendees.Except(calendarEvent2.OptionalAttendees).Any()
&& calendarEvent2.OptionalAttendees.Except(calendarEvent1.OptionalAttendees).Any()
&& (calendarEvent1.Description ?? string.Empty).Equals(calendarEvent2.Description ?? string.Empty)
&& calendarEvent1.End.Equals(calendarEvent2.End)
&& calendarEvent1.Location.Equals(calendarEvent2.Location)
&& calendarEvent1.Organizer.Equals(calendarEvent2.Organizer)
&& calendarEvent1.RecurrenceId.Equals(calendarEvent2.RecurrenceId)
&& calendarEvent1.Start.Equals(calendarEvent2.Start)
&& (calendarEvent1.Subject ?? string.Empty).Equals(calendarEvent2.Subject ?? string.Empty)
&& calendarEvent1.UID.Equals(calendarEvent2.UID);
}
/// <summary>
/// Updates Requests for the current and next uptime
/// </summary>
public void Update()
{
//get current uptime requests
this.CurrentUptimeRequests = m_UptimeManagement.GetAllRequestsForUptime(false).ToList();
this.CombinedCurrentUptimeRequest = CombineUptimeRequests(CurrentUptimeRequests);
//determine when the current uptime ends
var currentUptimeEnd = this.CurrentUptimeRequests.Any()
? this.CurrentUptimeRequests.Max(request => request.End)
: DateTime.Now;
//get the start of the next uptime after the end of the current uptime
var nextUptimeStart = m_UptimeManagement.GetFirstUptimeRequest(currentUptimeEnd).Start;
//get all uptime requests for the uptime beginning at nextUptimeStart
this.NextUptimeRequests = m_UptimeManagement.GetAllRequestsForUptime(nextUptimeStart, false);
this.CombinedNextUptimeRequest = CombineUptimeRequests(this.NextUptimeRequests);
}
public bool DoCheck(ICalendarEvent ce)
{
return(_chain.Execute(_events, ce));
}
/// <summary>
/// Helper function to update the older of the two events.
/// </summary>
/// <param name="event1"></param>
/// <param name="event2"></param>
private void UpdateOldestEventCommonProperties(ICalendarEvent event1, ICalendarEvent event2)
{
// Otherwise, simply check the common properties and sync.
if (AreCommonCalendarEventPropertiesEqual(event1, event2))
{
return;
}
if (event1.Modified > event2.Modified)
{
CopyCommonCalendarEventProperties(event1, event2);
}
else
{
CopyCommonCalendarEventProperties(event2, event1);
}
}
/// <summary>
/// Synchronize two events we know are the same, changes mark the underlying object as dirty
/// </summary>
/// <param name="event1"></param>
/// <param name="event2"></param>
private void SynchronizeDeletedCalendarEvents(ICalendarEvent event1, ICalendarEvent event2)
{
// If both calendars are deleted, do nothing, we don't care.
if (event1.IsDeleted && event2.IsDeleted)
{
return;
}
// If one of the calendars is marked as deleted, and the other is not, then
// - If the least recently modified calendar is not deleted, we should mark it for deletion on sync
// - If the least recently modified calendar is deleted, we should mark it for un-deletion on sync (and update it's properties.)
if (event1.Modified > event2.Modified)
{
if (event1.IsDeleted)
{
event2.DeleteOnSync = true;
}
else
{
// If we're undeleting, update common properties.
event2.UnDeleteOnSync = true;
UpdateOldestEventCommonProperties(event1, event2);
}
}
else
{
if (event2.IsDeleted)
{
event1.DeleteOnSync = true;
}
else
{
// If we're undeleting, update common properties.
event1.UnDeleteOnSync = true;
UpdateOldestEventCommonProperties(event1, event2);
}
}
}
public virtual bool Check(List <CalendarEvent> events, ICalendarEvent ce)
{
return(_nextCheck.Check(events, ce));
}
public Task Add(ICalendarEvent cEvent)
{
_context.CalendarEvents.Add((CalendarEvent)cEvent);
return(Task.CompletedTask);
}
public int AddEvent(ICalendarEvent newEventModel)
{
return(_singleEventRepository.AddSingleEvent((SingleEvent)newEventModel.ToEntity()));
}
/// <summary>
/// Synchronize two events we know are the same, changes mark the underlying object as dirty
/// </summary>
/// <param name="event1"></param>
/// <param name="event2"></param>
private void SynchronizeCalendarEvents(ICalendarEvent event1, ICalendarEvent event2)
{
// If either calendar is marked for deletion, we have a special case
if (event1.IsDeleted || event2.IsDeleted)
{
SynchronizeDeletedCalendarEvents(event1, event2);
return;
}
// Otherwise, update oldest common properties.
UpdateOldestEventCommonProperties(event1, event2);
}
public int AddEventSeries(ICalendarEvent newEventModel)
{
return(_eventSeriesRepository.AddEventSeries((EventSeries)newEventModel.ToEntity()));
}
public int ExcludeEventFromSeries(int seriesId, ICalendarEvent newEventModel)
{
return(_eventSeriesRepository.ExcludeEventFromSeries(seriesId, (EventFromSeries)newEventModel.ToEntity()));
}
public bool Execute(List <CalendarEvent> events, ICalendarEvent ce)
{
return(handler.Check(events, ce));
}
public RemoveEventOutput(ICalendarEvent e)
{
EventId = ((CalendarEvent)e).Id;
}
public override bool Check(List <CalendarEvent> events, ICalendarEvent ce)
{
return(true);
}
public bool Add(ICalendarEvent entity)
{
Context.CalendarEvents.Add((CalendarEvent)entity);
Context.SaveChanges();
return(true);
}
public bool HasEvent(ICalendarEvent calendarEvent)
{
return(this.events.First(ce => ce == calendarEvent) != null);
}
public void Add(ICalendarEvent eventObject)
{
Events.Add(eventObject);
}
/// <summary>
/// Determines whether a uptime request is active at a specified time
/// </summary>
/// <param name="now">The time for which to check the activeness of the request</param>
/// <param name="calendarEvent">The uptime request to check</param>
bool IsActiveRequest(DateTime now, ICalendarEvent calendarEvent)
=> IsActiveRequest(now, calendarEvent.Start, calendarEvent.End);
