/// <summary>
/// Get intersection of two TimeWindow.
/// </summary>
/// <param name="first">First timewindow.</param>
/// <param name="second">Second timewindow.</param>
/// <returns>If they intersects - return intersection
/// timewindow, otherwise - return 'null'.</returns>
public TimeWindow Intersection(TimeWindow second)
{
// If one of timewindow is null - return null.
if (second == null)
{
return(null);
}
// If one of timewindows is wideopen - return other.
if (this.IsWideOpen)
{
return(second.Clone() as TimeWindow);
}
else if (second.IsWideOpen)
{
return(this.Clone() as TimeWindow);
}
// Detect intersection of two timewindows.
var start = this.EffectiveFrom > second.EffectiveFrom ?
this.EffectiveFrom : second.EffectiveFrom;
var finish = this.EffectiveTo < second.EffectiveTo ?
this.EffectiveTo : second.EffectiveTo;
if (start <= finish)
{
return(CreateFromEffectiveTimes(start, finish));
}
else
{
return(null);
}
}
/// <summary>
/// Initializes a new instance of the <c>TimeWindowBreak</c> class.
/// </summary>
public TimeWindowBreak()
{
// Set defaults.
var from = new TimeSpan(DEFAULT_FROM_HOURS, 0, 0);
var to = new TimeSpan(DEFAULT_TO_HOURS, 0, 0);
_timeWindow = new TimeWindow(from, to);
Duration = DefautDuration;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
/// <returns></returns>
public object Clone()
{
TimeWindow obj = new TimeWindow();
obj._from = _from;
obj._to = _to;
obj._day = _day;
obj._isWideOpen = _isWideOpen;
return(obj);
}
/// <summary>
/// Creates a new instance of <c>TimeWindow<c> class using effective times.
/// </summary>
/// <param name="effectiveFrom">Time offset of time window start from planned date.</param>
/// <param name="effectiveTo">Time offset of time window end from planned date.</param>
/// <exception cref="ArgumentException">Invalid time window parameter(s).</exception>
/// <returns>Created time window.</returns>
internal static TimeWindow CreateFromEffectiveTimes(TimeSpan effectiveFrom, TimeSpan effectiveTo)
{
if (!_ValidateTimeWindowEffectiveTime(effectiveFrom, effectiveTo))
{
throw new ArgumentException(Properties.Messages.Error_TimeWindowParameters);
}
TimeSpan fromTime = _GetTimeWithoutDays(effectiveFrom);
TimeSpan toTime = _GetTimeWithoutDays(effectiveTo);
TimeWindow newTimeWindow = new TimeWindow(fromTime, toTime, (uint)effectiveFrom.Days);
return(newTimeWindow);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Checks if stop's arrive date time violates given time windows.
/// </summary>
/// <param name="timeWindow1">First time window.</param>
/// <param name="timeWindow2">Second time window.</param>
/// <returns>True - if both time windows violated, false - otherwise.</returns>
private bool _AreTimeWindowsViolated(TimeWindow timeWindow1, TimeWindow timeWindow2)
{
Debug.Assert(timeWindow1 != null);
Debug.Assert(timeWindow2 != null);
// Violation check result.
bool isViolated = false;
// Location's time window is violated when 1-st and 2-d time window is violated.
if (ArriveTime.HasValue && Route.Schedule.PlannedDate.HasValue)
{
DateTime arriveDateTime = ArriveTime.Value;
DateTime plannedDateTime = Route.Schedule.PlannedDate.Value;
isViolated = !timeWindow1.DoesIncludeTime(arriveDateTime, plannedDateTime) &&
!timeWindow2.DoesIncludeTime(arriveDateTime, plannedDateTime);
}
else
{
isViolated = false;
}
return(isViolated);
}
/// <summary>
/// Compares this time window with another one using values of their properties.
/// </summary>
/// <param name="secondTimeWindow">TimeWindow to compare with this.</param>
/// <returns>True - if either both time windows are wide open or have equal
/// values of properties From, To and Day, otherwise - false.</returns>
internal bool EqualsByValue(TimeWindow secondTimeWindow)
{
bool result = false;
// If input parameter is invalid.
if (secondTimeWindow == null || this.GetType() != secondTimeWindow.GetType())
{
result = false;
}
// If one of TimeWindow is WideOpen they both must be wide open.
else if (IsWideOpen || secondTimeWindow.IsWideOpen)
{
result = IsWideOpen == secondTimeWindow.IsWideOpen;
}
// Compare From, To and Day properties.
else
{
result = (From == secondTimeWindow.From &&
To == secondTimeWindow.To &&
Day == secondTimeWindow.Day);
}
return(result);
}
/// <summary>
/// Checks is time windows intersects or not.
/// </summary>
/// <param name="timeWindow">Second time window.</param>
/// <returns>'True' if they are intersect, 'false' otherwise.</returns>
public bool Intersects(TimeWindow timeWindow)
{
return (Intersection(timeWindow) != null);
}
/// <summary>
/// Get intersection of two TimeWindow.
/// </summary>
/// <param name="first">First timewindow.</param>
/// <param name="second">Second timewindow.</param>
/// <returns>If they intersects - return intersection
/// timewindow, otherwise - return 'null'.</returns>
public TimeWindow Intersection(TimeWindow second)
{
// If one of timewindow is null - return null.
if (second == null)
return null;
// If one of timewindows is wideopen - return other.
if (this.IsWideOpen)
return second.Clone() as TimeWindow;
else if (second.IsWideOpen)
return this.Clone() as TimeWindow;
// Detect intersection of two timewindows.
var start = this.EffectiveFrom > second.EffectiveFrom ?
this.EffectiveFrom : second.EffectiveFrom;
var finish = this.EffectiveTo < second.EffectiveTo ?
this.EffectiveTo : second.EffectiveTo;
if (start <= finish)
{
return CreateFromEffectiveTimes(start, finish);
}
else
return null;
}
/// <summary>
/// Gets TimeWindow property and update control's layout accordingly.
/// </summary>
/// <param name="tw"></param>
protected void _TimeWindowToControlState(TimeWindow tw)
{
if (tw != null)
if (tw.IsWideOpen)
_IsWideopen.IsChecked = true;
_ToText.Time = tw.To;
_ToText.TimeSpan = _ToText.Time;
_FromText.Time = tw.From;
_FromText.TimeSpan = _FromText.Time;
_CellLabel.Text = tw.ToString();
}
/// <summary>
/// Gets TimeWindow property and update control's layout accordingly.
/// </summary>
/// <param name="timeWindow"></param>
protected void _TimeWindowToControlState(TimeWindow timeWindow)
{
if (timeWindow != null)
if (timeWindow.IsWideOpen)
_isWideopenCheckBox.IsChecked = true;
_toTimeTextBox.Time = timeWindow.To;
_toTimeTextBox.TimeSpan = _toTimeTextBox.Time;
_fromTimeTextBox.Time = timeWindow.From;
_fromTimeTextBox.TimeSpan = _fromTimeTextBox.Time;
_isDay2CheckBox.IsChecked = timeWindow.Day > 0;
_UpdateCellTextBlockText();
}
/// <summary>
/// Updates time window data in database.
/// </summary>
/// <param name="timeWindow">Time window data.</param>
/// <param name="isFirst">Defines which time window should be updated:
/// true - 1-st time window, otherwise 2-nd time window.</param>
private void _UpdateTimeWindowEntityData(TimeWindow timeWindow, bool isFirst)
{
if (isFirst)
{
if (!timeWindow.IsWideOpen)
{
_Entity.TW1From = timeWindow.EffectiveFrom.Ticks;
_Entity.TW1To = timeWindow.EffectiveTo.Ticks;
}
else
{
_Entity.TW1From = null;
_Entity.TW1To = null;
}
}
else
{
if (!timeWindow.IsWideOpen)
{
_Entity.TW2From = timeWindow.EffectiveFrom.Ticks;
_Entity.TW2To = timeWindow.EffectiveTo.Ticks;
}
else
{
_Entity.TW2From = null;
_Entity.TW2To = null;
}
}
}
/// <summary>
/// Initializes time window using effective to and effective from ticks.
/// </summary>
/// <param name="ticksFrom">Low boundary of time window in ticks.</param>
/// <param name="ticksTo">High boundary of time window in ticks.</param>
/// <param name="timeWindow">Time window to initialize.</param>
private void _InitTimeWindow(long? ticksFrom, long? ticksTo, ref TimeWindow timeWindow)
{
if ((null != ticksFrom) && (null != ticksTo))
_SetTimeWindow((long)ticksFrom, (long)ticksTo, ref timeWindow);
else
_ClearTimeWindow(ref timeWindow);
}
/// <summary>
/// Method creates time windows from route break.
/// </summary>
/// <param name="routeBreak">Route break to get time information.</param>
/// <returns>Time Window.</returns>
private TimeWindow _GetBreakTimeWindow(Break routeBreak)
{
TimeWindow breakTimeWindow = new TimeWindow
{
IsWideOpen = true
};
if (routeBreak is TimeWindowBreak)
{
var twBreak = routeBreak as TimeWindowBreak;
breakTimeWindow.From = twBreak.From;
breakTimeWindow.To = twBreak.To;
breakTimeWindow.IsWideOpen = false;
}
else
{
// Do nothing: any another break types have
// wideopen time windows.
}
return breakTimeWindow;
}
/// <summary>
/// Method set attributes for both time windows.
/// </summary>
/// <param name="attributes">Attributes.</param>
/// <param name="timeWindow1">Time window 1.</param>
/// <param name="timeWindow2">Time window 2.</param>
private void _SetTimeWindowsAttributes(AttrDictionary attributes,
ref TimeWindow timeWindow1, ref TimeWindow timeWindow2)
{
Debug.Assert(attributes != null);
Debug.Assert(timeWindow1 != null);
Debug.Assert(timeWindow2 != null);
// Swap time windows in case first is Wideopen but second isn't.
if (timeWindow1.IsWideOpen && !timeWindow2.IsWideOpen)
{
var temp = timeWindow1;
timeWindow1 = timeWindow2;
timeWindow2 = temp;
}
// Time window 1.
_SetTimeWindowAttribute(timeWindow1, NAAttribute.TW_START1, NAAttribute.TW_END1,
attributes);
// Time window 2.
_SetTimeWindowAttribute(timeWindow2, NAAttribute.TW_START2, NAAttribute.TW_END2,
attributes);
}
/// <summary>
/// Method fills TimeWindow attributes in correct format.
/// </summary>
/// <param name="timeWindow">TimeWindow value.</param>
/// <param name="attrNameStart">Format string for Start TimeWindow.</param>
/// <param name="attrNameEnd">Format string for End TimeWindow</param>
/// <param name="attributes">Attributes to fill in.</param>
private void _SetTimeWindowAttribute(TimeWindow timeWindow,
string attrNameStart,
string attrNameEnd,
AttrDictionary attributes)
{
attributes.SetTimeWindow(timeWindow, _plannedDate, attrNameStart, attrNameEnd);
}
/// <summary>
/// Checks if time window includes stop's arrive time.
/// </summary>
/// <param name="timeWindow">Time window.</param>
/// <param name="stop">Stop object (expected it has associated object either Location or Order).</param>
/// <returns>True if stop's arrive time is inside time window, false - otherwise.</returns>
private static bool _DoesTimeWindowIncludeStopArriveTime(TimeWindow timeWindow, Stop stop)
{
Debug.Assert(timeWindow != null);
Debug.Assert(stop != null);
// Stop's arrive time.
DateTime? arriveDateTime = stop.ArriveTime;
// Stop's planned time.
DateTime? plannedDateTime = stop.Route.Schedule.PlannedDate;
// Check if time window includes stop's arrive time.
bool result =
_DoesTimeWindowIncludeTime(timeWindow, arriveDateTime, plannedDateTime);
return result;
}
/// <summary>
/// Checks if time window includes given time.
/// </summary>
/// <param name="timeWindow">Time window.</param>
/// <param name="arriveDateTime">Arrive date time.</param>
/// <param name="plannedDateTime">Planned date time.</param>
/// <returns>True - if arrive time is inside time window, false - otherwise.</returns>
private static bool _DoesTimeWindowIncludeTime(TimeWindow timeWindow, DateTime? arriveDateTime, DateTime? plannedDateTime)
{
Debug.Assert(timeWindow != null);
bool result = false;
// Check if arrive and planned date time have values.
if (arriveDateTime.HasValue && plannedDateTime.HasValue)
{
// Check if arrive time is inside the time window.
result = timeWindow.DoesIncludeTime(arriveDateTime.Value, plannedDateTime.Value);
}
else
{
result = false;
}
return result;
}
/// <summary>
/// Checks is time windows intersects or not.
/// </summary>
/// <param name="timeWindow">Second time window.</param>
/// <returns>'True' if they are intersect, 'false' otherwise.</returns>
public bool Intersects(TimeWindow timeWindow)
{
return(Intersection(timeWindow) != null);
}
/// <summary>
/// Gets time window of stop by index (0 or 1).
/// </summary>
/// <param name="stop">Stop object (expected it has associated object either Location or Order).</param>
/// <param name="twIndex">Index of time window (use constants FIRST_TIME_WINDOW, SECOND_TIME_WINDOW).</param>
/// <returns>Requested time window.</returns>
private static TimeWindow _GetTimeWindowByIndex(Stop stop, int twIndex)
{
Debug.Assert(stop != null);
Debug.Assert(twIndex == FIRST_TIME_WINDOW || twIndex == SECOND_TIME_WINDOW);
// Requested time window.
TimeWindow timeWindow;
// If stop is Location.
if (stop.AssociatedObject is Location)
{
Location location = stop.AssociatedObject as Location;
timeWindow = (twIndex == FIRST_TIME_WINDOW) ?
location.TimeWindow :
location.TimeWindow2;
}
// If stop is Order.
else if (stop.AssociatedObject is Order)
{
Order order = stop.AssociatedObject as Order;
timeWindow = (twIndex == FIRST_TIME_WINDOW) ?
order.TimeWindow :
order.TimeWindow2;
}
else
{
// Unknown object.
Debug.Assert(false);
// Create default time window.
timeWindow = new TimeWindow();
}
return timeWindow;
}
/// <summary>
/// Creates a new instance of <c>TimeWindow<c> class using effective times.
/// </summary>
/// <param name="effectiveFrom">Time offset of time window start from planned date.</param>
/// <param name="effectiveTo">Time offset of time window end from planned date.</param>
/// <exception cref="ArgumentException">Invalid time window parameter(s).</exception>
/// <returns>Created time window.</returns>
internal static TimeWindow CreateFromEffectiveTimes(TimeSpan effectiveFrom, TimeSpan effectiveTo)
{
if (!_ValidateTimeWindowEffectiveTime(effectiveFrom, effectiveTo))
throw new ArgumentException(Properties.Messages.Error_TimeWindowParameters);
TimeSpan fromTime = _GetTimeWithoutDays(effectiveFrom);
TimeSpan toTime = _GetTimeWithoutDays(effectiveTo);
TimeWindow newTimeWindow = new TimeWindow(fromTime, toTime, (uint)effectiveFrom.Days);
return newTimeWindow;
}
/// <summary>
/// Sets time window 2 using data from database.
/// </summary>
/// <param name="entity">Entity object Locations.</param>
private void _SetTimeWindow2(DataModel.Locations entity)
{
_timeWindow2 =
TimeWindow.CreateFromEffectiveTimes(new TimeSpan((long)entity.OpenFrom2),
new TimeSpan((long)entity.OpenTo2));
}
/// <summary>
/// Compares this time window with another one using values of their properties.
/// </summary>
/// <param name="secondTimeWindow">TimeWindow to compare with this.</param>
/// <returns>True - if either both time windows are wide open or have equal
/// values of properties From, To and Day, otherwise - false.</returns>
internal bool EqualsByValue(TimeWindow secondTimeWindow)
{
bool result = false;
// If input parameter is invalid.
if (secondTimeWindow == null || this.GetType() != secondTimeWindow.GetType())
{
result = false;
}
// If one of TimeWindow is WideOpen they both must be wide open.
else if (IsWideOpen || secondTimeWindow.IsWideOpen)
{
result = IsWideOpen == secondTimeWindow.IsWideOpen;
}
// Compare From, To and Day properties.
else
{
result = (From == secondTimeWindow.From &&
To == secondTimeWindow.To &&
Day == secondTimeWindow.Day);
}
return result;
}
/// <summary>
/// Add Time window
/// </summary>
/// <param name="timeWindow">Source time window</param>
/// <param name="second">Is second time window</param>
/// <param name="inlines">Inlines to fill</param>
/// <param name="bolded">Is need to be bold inline</param>
private static void _AddTimeWindow(TimeWindow timeWindow, bool second, InlineCollection inlines, bool bolded)
{
string value = timeWindow.ToString();
string timewindowCaption = _timewindowCaption;
if (second)
timewindowCaption += "2";
_AddLine(timewindowCaption, value, inlines, bolded);
}
/// <summary>
/// Clears given time window.
/// </summary>
/// <param name="timeWindow">Time window to clear.</param>
private void _ClearTimeWindow(ref TimeWindow timeWindow)
{
timeWindow.From = new TimeSpan();
timeWindow.To = new TimeSpan();
timeWindow.Day = 0;
timeWindow.IsWideOpen = true;
}
/// <summary>
/// Sets time window using entity data.
/// </summary>
/// <param name="entity"></param>
private void _SetTimeWindow(DataModel.Routes entity)
{
_timeWindow =
TimeWindow.CreateFromEffectiveTimes(new TimeSpan((long)entity.WorkFrom),
new TimeSpan((long)entity.WorkTo));
}
/// <summary>
/// Creates time window using effective to and effective from ticks and stores result to
/// the output parameter.
/// </summary>
/// <param name="ticksFrom">Low boundary of time window in ticks.</param>
/// <param name="ticksTo">High boundary of time window in ticks.</param>
/// <param name="timeWindow">Output parameter to store time window.</param>
private void _SetTimeWindow(long ticksFrom, long ticksTo, ref TimeWindow timeWindow)
{
// Create time window using effective times.
TimeWindow newTimeWindow =
TimeWindow.CreateFromEffectiveTimes(new TimeSpan(ticksFrom), new TimeSpan(ticksTo));
timeWindow.From = newTimeWindow.From;
timeWindow.To = newTimeWindow.To;
timeWindow.Day = newTimeWindow.Day;
timeWindow.IsWideOpen = false;
}
/// <summary>
/// Sets time window 2 using data from database.
/// </summary>
/// <param name="entity">Entity object Locations.</param>
private void _SetTimeWindow2(DataModel.Locations entity)
{
_timeWindow2 =
TimeWindow.CreateFromEffectiveTimes(new TimeSpan((long)entity.OpenFrom2),
new TimeSpan((long)entity.OpenTo2));
}
/// <summary>
/// Transform values from control fields to TimeWindow value
/// </summary>
protected void _GetTimeWindowFromControl()
{
TimeWindow timeWindow = new TimeWindow();
timeWindow.IsWideOpen = (bool)_isWideopenCheckBox.IsChecked;
timeWindow.From = _fromTimeTextBox.Time;
timeWindow.To = _toTimeTextBox.Time;
timeWindow.Day = (bool)_isDay2CheckBox.IsChecked ? 1u : 0u;
TimeWindow = timeWindow;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
/// <returns></returns>
public object Clone()
{
TimeWindow obj = new TimeWindow();
obj._from = _from;
obj._to = _to;
obj._day = _day;
obj._isWideOpen = _isWideOpen;
return obj;
}
/// <summary>
/// Initializes a new instance of the <c>TimeWindowBreak</c> class.
/// </summary>
public TimeWindowBreak()
{
// Set defaults.
var from = new TimeSpan (DEFAULT_FROM_HOURS, 0, 0);
var to = new TimeSpan(DEFAULT_TO_HOURS, 0, 0);
_timeWindow = new TimeWindow(from, to);
Duration = DefautDuration;
}
/// <summary>
/// Transform values from control fields to TimeWindow value.
/// </summary>
protected void _GetTimeWindowFromControl()
{
TimeWindow tw = new TimeWindow();
tw.IsWideOpen = (bool)_IsWideopen.IsChecked;
tw.From = _FromText.Time;
tw.To = _ToText.Time;
TimeWindow = tw;
}