public void InvertedTimeInterval_Contains_False()
{
var interval = new TimeInterval(SampleStartInverted, SampleEndInverted);
Assert.IsFalse(interval.Contains(new LocalTime(1, 00)));
Assert.IsFalse(interval.Contains(new LocalTime(1, 01)));
Assert.IsFalse(interval.Contains(new LocalTime(13, 00)));
Assert.IsFalse(interval.Contains(new LocalTime(22, 30)));
Assert.IsFalse(interval.Contains(new LocalTime(22, 59)));
}
public void InvertedTimeInterval_Contains_True()
{
var interval = new TimeInterval(SampleStartInverted, SampleEndInverted);
Assert.IsTrue(interval.Contains(new LocalTime(23, 00)));
Assert.IsTrue(interval.Contains(new LocalTime(23, 30)));
Assert.IsTrue(interval.Contains(new LocalTime(00, 00)));
Assert.IsTrue(interval.Contains(new LocalTime(00, 30)));
Assert.IsTrue(interval.Contains(new LocalTime(00, 59)));
}
public void TestContains()
{
Assert.IsFalse(TimeInterval.Empty.Contains(new JulianDate(2451545.0)));
TimeInterval interval1 = new TimeInterval(new JulianDate(2451545.0), new JulianDate(2451546.0));
Assert.IsTrue(interval1.Contains(new JulianDate(2451545.0)));
Assert.IsTrue(interval1.Contains(new JulianDate(2451545.5)));
Assert.IsTrue(interval1.Contains(new JulianDate(2451546.0)));
Assert.IsFalse(interval1.Contains(new JulianDate(2451546.5)));
}
private void FetchAppointmentsExecute(DevExpress.XtraScheduler.FetchAppointmentsEventArgs e)
{
TimeInterval currentInterval = e.Interval as TimeInterval;
if (lastFetchedInterval.Contains(currentInterval))
{
return;
}
lastFetchedInterval = currentInterval;
//
var entities = from entity in context.IHP_HARMONOGRAM_DZIENNY
where (entity.CZASSTART <lastFetchedInterval.End && entity.CZASSTOP> lastFetchedInterval.Start)
select entity;
entities.Load();
var Appo = context.IHP_HARMONOGRAM_DZIENNY.Local.ToList();
Appointments.Clear();
foreach (IHP_HARMONOGRAM_DZIENNY item in Appo)
{
// item.TEMAT = item.ARIT_HARMONOGRAM.HODOWCA ;
// item.LABELID = 2;
// item.WagaSr = 22;
Appointments.Add(item);
}
}
private void OnAppointmentsFetch(object sender, FetchAppointmentsEventArgs e)
{
DateTime start = e.Interval.Start;
DateTime end = e.Interval.End;
if (isDirty || !lastFetchedInterval.Contains(e.Interval) || lastFetchedResource != Filter.Current.User)
{
isDirty = false;
lastFetchedInterval = new TimeInterval(
start - TimeSpan.FromDays(7),
end + TimeSpan.FromDays(7));
lastFetchedResource = Filter.Current.User;
schedulerControl.Enabled = false;
dateNavigator.Enabled = false;
gridControl.Enabled = false;
try {
Fill(lastFetchedInterval, Filter.Current.User, Program.Service);
} finally {
schedulerControl.Enabled = true;
dateNavigator.Enabled = true;
gridControl.Enabled = true;
}
}
}
/// <summary>
/// Returns the overlaps between the two time intervals.
/// </summary>
/// <remarks>
/// The result with contain either 0, 1 or 2 intervals. Both <paramref name="first"/> and <paramref name="second"/>
/// will always contain (see <see cref="Contains"/>) the returned time intervals.
/// </remarks>
/// <param name="first">A time interval.</param>
/// <param name="second">The time interval to find overlaps with.</param>
/// <returns>The overlaps between the two time intervals.</returns>
/// <exception cref="System.ArgumentNullException">If <paramref name="first"/> or <paramref name="second"/> is <c>null</c>.</exception>
public static IEnumerable <TimeInterval> GetOverlapsWith(this TimeInterval first, TimeInterval second)
{
if (first == null)
{
throw new System.ArgumentNullException(nameof(first));
}
if (second == null)
{
throw new System.ArgumentNullException(nameof(second));
}
// TODO: Try to simplify
if (!first.Overlaps(second))
{
yield break;
}
if (first.Contains(second))
{
yield return(second);
}
else if (second.Contains(first))
{
yield return(first);
}
else
{
var interval1 = new TimeInterval(first.Start, second.End);
if (first.Contains(interval1) && second.Contains(interval1))
{
yield return(interval1);
}
var interval2 = new TimeInterval(second.Start, first.End);
if (first.Contains(interval2) && second.Contains(interval2))
{
yield return(interval2);
}
}
}
public void Contains_MidnightStartAndEnd(LocalTime time, bool expected)
{
// Arrange
var interval = new TimeInterval(LocalTime.Midnight, LocalTime.Midnight);
// Act
var contains = interval.Contains(time);
// Assert
contains.Should().Be(expected);
}
public void Contains_EqualStartAndEnd(LocalTime time, bool expected)
{
// Arrange
var startAndEnd = Fixture.Create <LocalTime>();
var interval = new TimeInterval(startAndEnd, startAndEnd);
// Act
var contains = interval.Contains(time);
// Assert
contains.Should().Be(expected);
}
public void Contains_StartAfterEnd(LocalTime time, bool expected)
{
// Arrange
var interval = new TimeInterval(
new LocalTime(20, 00),
new LocalTime(08, 00)
);
// Act
var contains = interval.Contains(time);
// Assert
contains.Should().Be(expected);
}
public static object GenerateAgendaAppointmentCollection(ASPxSchedulerStorage storage, object resourceId)
{
List <Appointment> sourceAppointments = null;
if (Convert.ToInt32(resourceId) == -1)
{
sourceAppointments = storage.GetAppointments(SelectedInterval).ToList <Appointment>();
}
else
{
sourceAppointments = storage.GetAppointments(SelectedInterval).Where <Appointment>(apt => apt.ResourceId == resourceId || apt.ResourceIds.Contains(resourceId)).ToList <Appointment>();
}
AgendaAppointmentCollection agendaAppointments = new AgendaAppointmentCollection();
foreach (Appointment appointment in sourceAppointments)
{
TimeInterval currentDayInterval = new TimeInterval(appointment.Start.Date, appointment.Start.Date.AddDays(1));
string startTime = "";
string endTime = "";
if (currentDayInterval.Contains(appointment.End))
{
startTime = currentDayInterval.Start == appointment.Start ? "" : appointment.Start.TimeOfDay.ToString(@"hh\:mm");
endTime = currentDayInterval.End == appointment.End ? "" : appointment.End.TimeOfDay.ToString(@"hh\:mm");
agendaAppointments.Add(CreateAgendaAppointment(storage, appointment, currentDayInterval.Start, startTime, endTime));
}
else
{
startTime = currentDayInterval.Start == appointment.Start ? "" : appointment.Start.TimeOfDay.ToString(@"hh\:mm");
agendaAppointments.Add(CreateAgendaAppointment(storage, appointment, currentDayInterval.Start, startTime, ""));
while (true)
{
currentDayInterval = new TimeInterval(currentDayInterval.End, currentDayInterval.End.AddDays(1));
if (currentDayInterval.Contains(appointment.End))
{
endTime = currentDayInterval.End == appointment.End ? "" : appointment.End.TimeOfDay.ToString(@"hh\:mm");
agendaAppointments.Add(CreateAgendaAppointment(storage, appointment, currentDayInterval.Start, "", endTime));
break;
}
else
{
agendaAppointments.Add(CreateAgendaAppointment(storage, appointment, currentDayInterval.Start, "", ""));
}
}
}
}
return(agendaAppointments);
}
private void FetchAppointmentsExecute(DevExpress.XtraScheduler.FetchAppointmentsEventArgs e)
{
TimeInterval currentInterval = e.Interval as TimeInterval;
if (lastFetchedInterval.Contains(currentInterval))
{
return;
}
lastFetchedInterval = currentInterval;
var entities = from entity in carsXtraSchedulingEntities.CarSchedulings
where entity.EventType > 0 || (entity.StartTime <lastFetchedInterval.End && entity.EndTime> lastFetchedInterval.Start)
select entity;
entities.Load();
Appointments = carsXtraSchedulingEntities.CarSchedulings.Local.ToBindingList();
}
/// <summary>
/// Returns the date time intervals where <paramref name="timeInterval"/> overlaps <paramref name="dateTimeInterval"/>.
/// </summary>
/// <param name="timeInterval">The time interval.</param>
/// <param name="dateTimeInterval">The date time interval.</param>
/// <returns>Empty result, if the two intervals don't overlap; otherwise, each date time interval where they overlap.</returns>
/// <exception cref="System.ArgumentNullException">If <paramref name="timeInterval"/> or <paramref name="dateTimeInterval"/> is <c>null</c>.</exception>
public static IEnumerable <DateTimeInterval> GetOverlapsWith(this TimeInterval timeInterval, DateTimeInterval dateTimeInterval)
{
if (timeInterval == null)
{
throw new System.ArgumentNullException(nameof(timeInterval));
}
if (dateTimeInterval == null)
{
throw new System.ArgumentNullException(nameof(dateTimeInterval));
}
if (!timeInterval.Overlaps(dateTimeInterval))
{
yield break;
}
if (dateTimeInterval.IsSinglePointInterval())
{
yield return(dateTimeInterval);
yield break;
}
var start = timeInterval.Contains(dateTimeInterval.Start.TimeOfDay)
? dateTimeInterval.Start
: dateTimeInterval.Start.NextOrSame(timeInterval.Start);
var end = start.Next(timeInterval.End);
while (start < dateTimeInterval.End)
{
if (dateTimeInterval.End < end)
{
end = dateTimeInterval.End;
}
yield return(new DateTimeInterval(start, end));
start = start.Next(timeInterval.Start);
end = start.Next(timeInterval.End);
}
}
/// <summary>
/// Determines whether the time interval overlaps the date time interval.
/// </summary>
/// <param name="timeInterval">The time interval.</param>
/// <param name="dateTimeInterval">The date time interval.</param>
/// <returns><c>true</c> if the time interval overlaps the date time interval; <c>false</c>, otherwise.</returns>
/// <remarks>
/// This will always be <c>true</c> for date time intervals that are longer than a day.
/// </remarks>
/// <exception cref="System.ArgumentNullException">If <paramref name="timeInterval"/> or <paramref name="dateTimeInterval"/> is <c>null</c>.</exception>
public static bool Overlaps(this TimeInterval timeInterval, DateTimeInterval dateTimeInterval)
{
if (timeInterval == null)
{
throw new System.ArgumentNullException(nameof(timeInterval));
}
if (dateTimeInterval == null)
{
throw new System.ArgumentNullException(nameof(dateTimeInterval));
}
if (dateTimeInterval.IsSinglePointInterval())
{
return(timeInterval.Contains(dateTimeInterval.Start.TimeOfDay));
}
var maxEnd = dateTimeInterval.Start + Period.FromDays(1);
return(maxEnd < dateTimeInterval.End || dateTimeInterval.ToTimeInterval().Overlaps(timeInterval));
}
public static object GenerateAgendaAppointmentCollection(SchedulerStorage storage)
{
AppointmentBaseCollection sourceAppointments = storage.GetAppointments(SelectedInterval);
BindingList <AgendaAppointment> agendaAppointments = new BindingList <AgendaAppointment>();
foreach (Appointment appointment in sourceAppointments)
{
TimeInterval currentDayInterval = new TimeInterval(appointment.Start.Date, appointment.Start.Date.AddDays(1));
string startTime = "";
string endTime = "";
if (currentDayInterval.Contains(appointment.End))
{
startTime = currentDayInterval.Start == appointment.Start ? "" : appointment.Start.TimeOfDay.ToString(@"hh\:mm");
endTime = currentDayInterval.End == appointment.End ? "" : appointment.End.TimeOfDay.ToString(@"hh\:mm");
agendaAppointments.Add(CreateAgendaAppointment(storage, appointment, currentDayInterval.Start, startTime, endTime));
}
else
{
startTime = currentDayInterval.Start == appointment.Start ? "" : appointment.Start.TimeOfDay.ToString(@"hh\:mm");
agendaAppointments.Add(CreateAgendaAppointment(storage, appointment, currentDayInterval.Start, startTime, ""));
while (true)
{
currentDayInterval = new TimeInterval(currentDayInterval.End, currentDayInterval.End.AddDays(1));
if (currentDayInterval.Contains(appointment.End))
{
endTime = currentDayInterval.End == appointment.End ? "" : appointment.End.TimeOfDay.ToString(@"hh\:mm");
agendaAppointments.Add(CreateAgendaAppointment(storage, appointment, currentDayInterval.Start, "", endTime));
break;
}
else
{
agendaAppointments.Add(CreateAgendaAppointment(storage, appointment, currentDayInterval.Start, "", ""));
}
}
}
}
return(agendaAppointments);
}
void CorrectAppointmentParameters(AppointmentDragEventArgs e)
{
TimeSpan customScaleDuration = (maxTime - minTime).Add(TimeSpan.FromHours(2));
DateTime initialStart = e.EditedAppointment.Start;
if (e.EditedAppointment.Start.TimeOfDay < minTime || e.EditedAppointment.Start.TimeOfDay >= maxTime)
{
bool durationMustBeIncreased = e.EditedAppointment.Duration > customScaleDuration;
e.EditedAppointment.Start = durationMustBeIncreased ? e.EditedAppointment.Start + customScaleDuration : e.EditedAppointment.Start - customScaleDuration;
TimeInterval appInterval = new TimeInterval(e.EditedAppointment.Start, e.EditedAppointment.Start + e.EditedAppointment.Duration + customScaleDuration);
if (!appInterval.Contains(e.HitInterval))
{
durationMustBeIncreased = !durationMustBeIncreased;
e.EditedAppointment.Start = durationMustBeIncreased ? initialStart + customScaleDuration : initialStart - customScaleDuration;
}
}
if (e.EditedAppointment.End.TimeOfDay >= maxTime || e.EditedAppointment.End.TimeOfDay < minTime)
{
e.EditedAppointment.End = e.EditedAppointment.Duration > customScaleDuration ? e.EditedAppointment.End - customScaleDuration : e.EditedAppointment.End + customScaleDuration;
}
}
void CheckWorkTime()
{
var now = DateTime.Now;
if (now < dismissUntil)
{
return;
}
var begin = workTime.GetWorkBegin(now);
if (begin == null)
{
return;
}
var mustGo = begin.Value + Contract.MaxWorkTimePerDay;
var warn = new TimeInterval(mustGo - warnBefore, mustGo + warnAfter);
if (warn.Contains(now))
{
ShowWorkTimeAlert();
}
}
public void TestContains()
{
Assert.IsFalse(TimeInterval.Empty.Contains(new JulianDate(2451545.0)));
TimeInterval interval1 = new TimeInterval(new JulianDate(2451545.0), new JulianDate(2451546.0));
Assert.IsTrue(interval1.Contains(new JulianDate(2451545.0)));
Assert.IsTrue(interval1.Contains(new JulianDate(2451545.5)));
Assert.IsTrue(interval1.Contains(new JulianDate(2451546.0)));
Assert.IsFalse(interval1.Contains(new JulianDate(2451546.5)));
}
private int CountAppointmentsByCriteria(SchedulerHeader rh, TimeInterval visTime)
{
AppointmentBaseCollection col = schedulerControl1.ActiveView.GetAppointments().FindAll(delegate(Appointment apt) { return((apt.ResourceIds.Contains(rh.Resource.Id) || (Object.Equals(apt.ResourceId, ResourceEmpty.Id))) && (visTime.Contains(new TimeInterval(apt.Start, apt.End)))); });
return(col.Count);
}
private bool ProcessFile(Guid aFolderId, string aSourceFilePath, MaterialFolderIndexRecord aNewRecord, TimeInterval aInterval, string aNewFilePath)
{
bool result = false;
bool waitforIntra = true;
Guid clientGuid = Guid.NewGuid();
try
{
using (FileStream file = File.OpenRead(aSourceFilePath))
{
using (IMaterialFile newFile = MaterialFileFactory.CreateMaterialFile(aFolderId, aNewRecord, aNewFilePath))
{
int readBytes = 0;
int startFrameOffset = 0;
bool startFound = false;
byte[] buffer = new byte[16 * 1024];
DateTime lastFrameTimeStamp = DateTime.MinValue;
List <byte> frameBuffer = new List <byte>();
do
{
if (_stopTask.IsCancellationRequested)
{
return(false);
}
startFrameOffset = 0;
readBytes = file.Read(buffer, 0, buffer.Length);
for (int pos = 0; pos < readBytes - Constants.FrameStart.Length; ++pos)
{
if (IsEqual(buffer, pos, Constants.FrameStart))
{
startFound = true;
startFrameOffset = pos;
frameBuffer.Clear();
}
if (IsEqual(buffer, pos, Constants.FrameEnd))
{
int endFramePos = pos + Constants.FrameEnd.Length;
CopyBuffer(frameBuffer, buffer, startFrameOffset, endFramePos);
startFound = false;
startFrameOffset = 0;
Frame frame = null;
try
{
using (MemoryStream stream = new MemoryStream(frameBuffer.ToArray()))
{
try
{
frame = new Frame();
frame.Deserialize(stream);
}
catch
{
continue;
}
if (frame.Metadata.Timestamp <= lastFrameTimeStamp)
{
// Skip old frames
continue;
}
if (frame.Metadata.ChannelId != aNewRecord.ChannelId || frame.DataType != aNewRecord.DataType)
{
// Skip other data
continue;
}
if (waitforIntra && !frame.Metadata.IsIntra)
{
// Skip non intra if we wait intra
continue;
}
waitforIntra = false;
if (aInterval.Contains(frame.Metadata.Timestamp))
{
MaterialPosition position = null;
WriteStatus writeStatus = newFile.Write(frame, ref position);
if (writeStatus == WriteStatus.OK)
{
// Update material folder index record
if (aNewRecord.BeginTimestamp.Ticks == 0)
{
aNewRecord.BeginTimestamp = frame.Metadata.Timestamp;
}
aNewRecord.EndTimestamp = frame.Metadata.Timestamp;
// Update result
result = true;
// Add to frame times
lastFrameTimeStamp = frame.Metadata.Timestamp;
}
else
{
SendError($"Write frame error, status: {writeStatus}, source file {aSourceFilePath}, destination file {aNewFilePath}!");
waitforIntra = true;
}
}
}
}
catch (Exception ex)
{
SendError(ex.Message);
waitforIntra = true;
}
finally
{
frame?.Release();
}
}
}
if (startFound)
{
CopyBuffer(frameBuffer, buffer, startFrameOffset, buffer.Length);
}
} while (readBytes > 0);
}
}
}
catch (Exception ex)
{
SendError(ex.Message);
}
return(result);
}
