/// <summary>
/// Get work hours for the given time block.
/// </summary>
/// <param name="timePeriod">The time block according to which the calculations are to be performed.</param>
/// <returns></returns>
public int Goal(ITimeBlock timePeriod)
{
// Holidays API
// 1000 Non commercial use only Attribution Required
// https://calendarific.com/account
throw new NotImplementedException();
}
public void CopyTest()
{
TimeBlock readOnlyTimeBlock = new TimeBlock(_start, _duration);
Assert.AreEqual(readOnlyTimeBlock.Copy(TimeSpan.Zero), readOnlyTimeBlock);
TimeBlock timeBlock = new TimeBlock(_start, _duration);
Assert.AreEqual(timeBlock.Start, _start);
Assert.AreEqual(timeBlock.End, _end);
Assert.AreEqual(timeBlock.Duration, _duration);
ITimeBlock noMoveTimeBlock = timeBlock.Copy(TimeSpan.Zero);
Assert.AreEqual(noMoveTimeBlock.Start, _start);
Assert.AreEqual(noMoveTimeBlock.End, _end);
Assert.AreEqual(noMoveTimeBlock.Duration, _duration);
TimeSpan forwardOffset = new TimeSpan(2, 30, 15);
ITimeBlock forwardTimeBlock = timeBlock.Copy(forwardOffset);
Assert.AreEqual(forwardTimeBlock.Start, _start.Add(forwardOffset));
Assert.AreEqual(forwardTimeBlock.End, _end.Add(forwardOffset));
Assert.AreEqual(forwardTimeBlock.Duration, _duration);
TimeSpan backwardOffset = new TimeSpan(-1, 10, 30);
ITimeBlock backwardTimeBlock = timeBlock.Copy(backwardOffset);
Assert.AreEqual(backwardTimeBlock.Start, _start.Add(backwardOffset));
Assert.AreEqual(backwardTimeBlock.End, _end.Add(backwardOffset));
Assert.AreEqual(backwardTimeBlock.Duration, _duration);
}
public void CopyTest()
{
TimeBlock readOnlyTimeBlock = new TimeBlock(start, duration);
Assert.Equal(readOnlyTimeBlock.Copy(TimeSpan.Zero), readOnlyTimeBlock);
TimeBlock timeBlock = new TimeBlock(start, duration);
Assert.Equal <DateTime>(timeBlock.Start, start);
Assert.Equal <DateTime>(timeBlock.End, end);
Assert.Equal <TimeSpan>(timeBlock.Duration, duration);
ITimeBlock noMoveTimeBlock = timeBlock.Copy(TimeSpan.Zero);
Assert.Equal <DateTime>(noMoveTimeBlock.Start, start);
Assert.Equal <DateTime>(noMoveTimeBlock.End, end);
Assert.Equal <TimeSpan>(noMoveTimeBlock.Duration, duration);
TimeSpan forwardOffset = new TimeSpan(2, 30, 15);
ITimeBlock forwardTimeBlock = timeBlock.Copy(forwardOffset);
Assert.Equal <DateTime>(forwardTimeBlock.Start, start.Add(forwardOffset));
Assert.Equal <DateTime>(forwardTimeBlock.End, end.Add(forwardOffset));
Assert.Equal <TimeSpan>(forwardTimeBlock.Duration, duration);
TimeSpan backwardOffset = new TimeSpan(-1, 10, 30);
ITimeBlock backwardTimeBlock = timeBlock.Copy(backwardOffset);
Assert.Equal <DateTime>(backwardTimeBlock.Start, start.Add(backwardOffset));
Assert.Equal <DateTime>(backwardTimeBlock.End, end.Add(backwardOffset));
Assert.Equal <TimeSpan>(backwardTimeBlock.Duration, duration);
} // CopyTest
public void GetNextPeriodTest()
{
TimeBlock readOnlyTimeBlock = new TimeBlock(start, duration, true);
Assert.True(readOnlyTimeBlock.GetNextPeriod().IsReadOnly);
TimeBlock timeBlock = new TimeBlock(start, duration);
Assert.Equal(timeBlock.Start, start);
Assert.Equal(timeBlock.End, end);
Assert.Equal(timeBlock.Duration, duration);
ITimeBlock nextTimeBlock = timeBlock.GetNextPeriod();
Assert.Equal(nextTimeBlock.Start, end);
Assert.Equal(nextTimeBlock.End, end.Add(duration));
Assert.Equal(nextTimeBlock.Duration, duration);
TimeSpan nextOffset = Duration.Hour;
ITimeBlock nextOffsetTimeBlock = timeBlock.GetNextPeriod(nextOffset);
Assert.Equal(nextOffsetTimeBlock.Start, end.Add(nextOffset));
Assert.Equal(nextOffsetTimeBlock.End, end.Add(duration + nextOffset));
Assert.Equal(nextOffsetTimeBlock.Duration, duration);
} // GetNextPeriodTest
public void GetPreviousPeriodTest()
{
TimeBlock readOnlyTimeBlock = new TimeBlock(start, duration, true);
Assert.True(readOnlyTimeBlock.GetPreviousPeriod().IsReadOnly);
TimeBlock timeBlock = new TimeBlock(start, duration);
Assert.Equal(timeBlock.Start, start);
Assert.Equal(timeBlock.End, end);
Assert.Equal(timeBlock.Duration, duration);
ITimeBlock previousTimeBlock = timeBlock.GetPreviousPeriod();
Assert.Equal(previousTimeBlock.Start, start.Subtract(duration));
Assert.Equal(previousTimeBlock.End, start);
Assert.Equal(previousTimeBlock.Duration, duration);
TimeSpan previousOffset = Duration.Hour.Negate();
ITimeBlock previousOffsetTimeBlock = timeBlock.GetPreviousPeriod(previousOffset);
Assert.Equal(previousOffsetTimeBlock.Start, start.Subtract(duration).Add(previousOffset));
Assert.Equal(previousOffsetTimeBlock.End, end.Subtract(duration).Add(previousOffset));
Assert.Equal(previousOffsetTimeBlock.Duration, duration);
} // GetPreviousPeriodTest
public void GetNextPeriodTest()
{
TimeBlock readOnlyTimeBlock = new TimeBlock(_start, _duration, true);
Assert.IsTrue(readOnlyTimeBlock.GetNextBlock().IsReadOnly);
TimeBlock timeBlock = new TimeBlock(_start, _duration);
Assert.AreEqual(timeBlock.Start, _start);
Assert.AreEqual(timeBlock.End, _end);
Assert.AreEqual(timeBlock.Duration, _duration);
ITimeBlock nextTimeBlock = timeBlock.GetNextBlock();
Assert.AreEqual(nextTimeBlock.Start, _end);
Assert.AreEqual(nextTimeBlock.End, _end.Add(_duration));
Assert.AreEqual(nextTimeBlock.Duration, _duration);
TimeSpan nextOffset = TimeSpan.FromHours(1);
ITimeBlock nextOffsetTimeBlock = timeBlock.GetNextBlock(nextOffset);
Assert.AreEqual(nextOffsetTimeBlock.Start, _end.Add(nextOffset));
Assert.AreEqual(nextOffsetTimeBlock.End, _end.Add(_duration + nextOffset));
Assert.AreEqual(nextOffsetTimeBlock.Duration, _duration);
}
public void GetIntersectionTest()
{
TimeBlock readOnlyTimeBlock = new TimeBlock(start, duration);
Assert.Equal(readOnlyTimeBlock.GetIntersection(readOnlyTimeBlock), new TimeBlock(readOnlyTimeBlock));
TimeBlock timeBlock = new TimeBlock(start, duration);
// before
ITimeBlock before1 = timeBlock.GetIntersection(new TimeBlock(start.AddHours(-2), start.AddHours(-1)));
Assert.Null(before1);
ITimeBlock before2 = timeBlock.GetIntersection(new TimeBlock(start.AddMilliseconds(-1), start));
Assert.Equal(before2, new TimeBlock(start));
ITimeBlock before3 = timeBlock.GetIntersection(new TimeBlock(start.AddMilliseconds(-1), start.AddMilliseconds(1)));
Assert.Equal(before3, new TimeBlock(start, start.AddMilliseconds(1)));
// after
ITimeBlock after1 = timeBlock.GetIntersection(new TimeBlock(end.AddHours(1), end.AddHours(2)));
Assert.Null(after1);
ITimeBlock after2 = timeBlock.GetIntersection(new TimeBlock(end, end.AddMilliseconds(1)));
Assert.Equal(after2, new TimeBlock(end));
ITimeBlock after3 = timeBlock.GetIntersection(new TimeBlock(end.AddMilliseconds(-1), end.AddMilliseconds(1)));
Assert.Equal(after3, new TimeBlock(end.AddMilliseconds(-1), end));
// intersect
Assert.Equal(timeBlock.GetIntersection(timeBlock), timeBlock);
ITimeBlock itersect1 = timeBlock.GetIntersection(new TimeBlock(start.AddMilliseconds(-1), end.AddMilliseconds(1)));
Assert.Equal(itersect1, timeBlock);
ITimeBlock itersect2 = timeBlock.GetIntersection(new TimeBlock(start.AddMilliseconds(1), end.AddMilliseconds(-1)));
Assert.Equal(itersect2, new TimeBlock(start.AddMilliseconds(1), end.AddMilliseconds(-1)));
} // GetIntersectionTest
public void GetIntersectionTest()
{
TimeBlock readOnlyTimeBlock = new TimeBlock(_start, _duration);
Assert.AreEqual(readOnlyTimeBlock.GetIntersectionBlock(readOnlyTimeBlock), new TimeBlock(readOnlyTimeBlock));
TimeBlock timeBlock = new TimeBlock(_start, _duration);
// before
ITimeBlock before1 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddHours(-2), _start.AddHours(-1)));
Assert.AreEqual(before1, null);
ITimeBlock before2 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddMilliseconds(-1), _start));
Assert.AreEqual(before2, new TimeBlock(_start));
ITimeBlock before3 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddMilliseconds(-1), _start.AddMilliseconds(1)));
Assert.AreEqual(before3, new TimeBlock(_start, _start.AddMilliseconds(1)));
// after
ITimeBlock after1 = timeBlock.GetIntersectionBlock(new TimeBlock(_end.AddHours(1), _end.AddHours(2)));
Assert.AreEqual(after1, null);
ITimeBlock after2 = timeBlock.GetIntersectionBlock(new TimeBlock(_end, _end.AddMilliseconds(1)));
Assert.AreEqual(after2, new TimeBlock(_end));
ITimeBlock after3 = timeBlock.GetIntersectionBlock(new TimeBlock(_end.AddMilliseconds(-1), _end.AddMilliseconds(1)));
Assert.AreEqual(after3, new TimeBlock(_end.AddMilliseconds(-1), _end));
// intersect
Assert.AreEqual(timeBlock.GetIntersectionBlock(timeBlock), timeBlock);
ITimeBlock itersect1 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddMilliseconds(-1), _end.AddMilliseconds(1)));
Assert.AreEqual(itersect1, timeBlock);
ITimeBlock itersect2 = timeBlock.GetIntersectionBlock(new TimeBlock(_start.AddMilliseconds(1), _end.AddMilliseconds(-1)));
Assert.AreEqual(itersect2, new TimeBlock(_start.AddMilliseconds(1), _end.AddMilliseconds(-1)));
}
public static TimePeriod[] MakeArray(ITimeBlock[] list, int quantum)
{
if (list != null && list.Length > 0)
{
List<TimePeriod> tbList = new List<TimePeriod>();
foreach (ITimeBlock tb in list)
{
tbList.Add(new TimePeriod(tb.Start, tb.Duration,quantum));
}
return tbList.ToArray();
}
else return null;
}
public int Split(ITimeBlock subBlock, ref TimeBlock intersection, ref TimeBlock previous, ref TimeBlock remaining)
{
int status = 0;
intersection = null;
previous = null;
remaining = null;
if (Intersects(subBlock))
{
intersection = Intersection(subBlock);
if (startTime < intersection.Start)
{
previous = new TimeBlock(startTime, intersection.Start);
status |= 1;
}
else if (intersection.Start > subBlock.Start)
{
previous = new TimeBlock(subBlock.Start, intersection.Start);
status |= 2;
}
if (End > intersection.End)
{
remaining = new TimeBlock(intersection.End, End);
status |= 4;
}
else if (subBlock.End > intersection.End)
{
remaining = new TimeBlock(intersection.End, subBlock.End);
status |= 8;
}
}
return status;
}
public bool Contains(ITimeBlock target)
{
return ((this.startTime <= target.Start) && (this.End >= target.End));
}
public TimeBlock Intersection(ITimeBlock target)
{
if (Intersects(target))
{
DateTime start = (Start > target.Start) ? Start : target.Start;
DateTime end = (End < target.End) ? End : target.End;
return new TimeBlock(start, end);
}
else
return null;
}
private int renderScheduledTime(HtmlTextWriter output, ITimeBlock tb)
{
output.WriteLine();
output.RenderBeginTag("tr");
int height = Convert.ToInt32((((hourHeight * tb.Duration)/3600.0)));
//output.AddAttribute("onclick", "javascript:" + Page.ClientScript.GetPostBackEventReference(this, startTime.ToString("s")));
output.AddStyleAttribute("background-color", ColorTranslator.ToHtml(scheduledColor));
output.AddStyleAttribute("cursor", "hand");
output.AddStyleAttribute("border-bottom", "1px solid " + ColorTranslator.ToHtml(BorderColor));
output.AddStyleAttribute("height", height + "px");
output.AddAttribute("title", tb.Start.AddMinutes(userTZ).TimeOfDay.ToString() + " - " + tb.End.AddMinutes(userTZ).TimeOfDay.ToString());
output.RenderBeginTag("td");
//if(height > 24)
// output.Write(tb.Start.AddMinutes(userTZ).TimeOfDay );
//if(height > 48)
// output.Write(" - " + tb.End.AddMinutes(userTZ).TimeOfDay);
output.RenderEndTag();
output.RenderEndTag();
return height;
}
public static bool HasUnion(ITimeBlock a, ITimeBlock b)
{
return (a.Start <= b.End && a.End >= b.Start);
}
public static TimeBlock[] Concatenate(ITimeBlock[] listIn)
{
if (listIn != null && listIn.Length > 0)
{
TimeBlock[] list = TimeBlock.MakeArray(listIn);
TimeBlock wrk = null;
bool cont = true;
while (cont)
{
cont = false;
bool[] status = new bool[list.Length];
List<TimeBlock> returnList = new List<TimeBlock>();
for (int i = 0; i < list.Length; i++)
{
if (!status[i])
{
status[i] = true;
wrk = list[i];
for (int j = i + 1; j < list.Length; j++)
{
if (!status[j])
{
if (TimeBlock.HasUnion(wrk, list[j]))
{
wrk = TimeBlock.Union(wrk,list[j]);
status[j] = true;
cont = true;
}
}
}
returnList.Add(wrk);
}
}
list = returnList.ToArray();
}
return list;
}
else return null;
}
public static TimeBlock[] Remaining(ITimeBlock[] range, ITimeBlock[] remove)
{
List<TimeBlock> rangeList = null;
List<TimeBlock> removeBlocks = new List<TimeBlock>();
List<TimeBlock> removeList = new List<TimeBlock>();
List<TimeBlock> addList = new List<TimeBlock>();
int minTime = 0;
if (range != null && range.Length > 0)
{
rangeList = new List<TimeBlock>();
rangeList.AddRange(TimeBlock.Concatenate(range));
if (remove != null && remove.Length > 0)
{
removeList.AddRange(TimeBlock.MakeArray(remove));
TimeBlock tmp;
int code = 0;
int hit = 0;
TimeBlock intersection = null;
TimeBlock previous = null;
TimeBlock remainder = null;
foreach (TimeBlock remTB in removeList)
{
foreach (TimeBlock rangeTB in rangeList)
{
intersection = null;
previous = null;
remainder = null;
if (rangeTB.Intersects(remTB))
{
code = rangeTB.Split(remTB, ref intersection, ref previous, ref remainder);
if (previous != null)
{
addList.Add(previous);
}
if (remainder != null)
{
addList.Add(remainder);
}
}
else
{
addList.Add(rangeTB);
}
}
rangeList.Clear();
rangeList.AddRange(addList);
addList.Clear();
}
}
}
if (rangeList != null)
{
return rangeList.ToArray();
}
else return null;
}
public static TimeBlock[] Remaining_1(ITimeBlock[] range, ITimeBlock[] remove)
{
List<TimeBlock> rangeList = null;
int minTime = 0;
if (range != null && range.Length > 0)
{
rangeList = new List<TimeBlock>();
rangeList.AddRange(TimeBlock.MakeArray(range));
if (remove != null && remove.Length > 0)
{
List<TimeBlock> removeList = new List<TimeBlock>();
removeList.AddRange(TimeBlock.MakeArray(remove));
TimeBlock tmp;
int code = 0;
int hit = 0;
List<TimeBlock> addBlocks = new List<TimeBlock>();
List<TimeBlock> removeBlocks = new List<TimeBlock>();
foreach (TimeBlock remTB in removeList)
{
if (removeBlocks.Count > 0)
{
foreach (TimeBlock rt in removeBlocks)
{
rangeList.Remove(rt);
}
removeBlocks.Clear();
}
if (addBlocks.Count > 0)
{
rangeList.AddRange(addBlocks);
addBlocks.Clear();
}
TimeBlock intersection = null;
TimeBlock previous = null;
TimeBlock remainder = null;
foreach (TimeBlock tb in rangeList)
{
if (tb.duration > minTime)
{
if (remTB.Intersects(tb))
{
removeBlocks.Add(tb);
code = tb.Split(remTB, ref intersection, ref previous, ref remainder);
if ((code & 1) == 1)
{
if (previous.duration >= minTime)
{
addBlocks.Add(previous);
}
}
if ((code & 4) == 4)
{
if (remainder.duration >= minTime)
{
addBlocks.Add(remainder);
}
}
}
}
else
{
removeBlocks.Add(tb);
}
}
}
}
}
if (rangeList != null)
{
return rangeList.ToArray();
}
else return null;
}
public int CompareTo(ITimeBlock b)
{
int status = 0;
if (Start > b.Start)
{
status = 1;
}
else if (Start < b.Start)
{
status = -1;
}
else if (Duration > b.Duration)
{
status = 1;
}
else if (Duration < b.Duration)
{
status = -1;
}
return status;
}
public static TimeBlock Union(ITimeBlock a, ITimeBlock b)
{
TimeBlock tb = null;
if(TimeBlock.HasUnion(a,b))
tb = new TimeBlock(a.Start <= b.Start ? a.Start : b.Start,a.End >= b.End ?a.End:b.End);
return tb;
}
public bool Intersects(ITimeBlock target)
{
return (this.Start < target.End && this.End > target.Start);
}
private int renderScheduledTime(HtmlTextWriter output, ITimeBlock tb)
{
int duration = 0;
if (tb.End < endOfDay)
duration = tb.Duration;
else
duration = new TimeBlock(tb.Start, endOfDay).Duration;
if (duration > 0)
{
output.Write("<tr>");
int height = Convert.ToInt32((((hourHeight * duration) / 3600.0)));
//output.AddAttribute("onclick", "javascript:" + Page.ClientScript.GetPostBackEventReference(this, startTime.ToString("s")));
#if useStyle
output.AddStyleAttribute(HtmlTextWriterStyle.Padding, zero.ToString());
output.AddStyleAttribute(HtmlTextWriterStyle.Margin, zero.ToString());
output.AddStyleAttribute("background-color", ColorTranslator.ToHtml(scheduledColor));
output.AddStyleAttribute("cursor", "hand");
//output.AddStyleAttribute("border-bottom", "1px solid " + ColorTranslator.ToHtml(BorderColor));
#endif
output.AddAttribute("class", reservedClass);
output.AddStyleAttribute("height", adjustHeight(height) + "px");
if (browserMode > 0)
{
output.AddStyleAttribute("border-bottom", "1px solid " + ColorTranslator.ToHtml(BorderColor));
output.AddStyleAttribute("background-color", ColorTranslator.ToHtml(scheduledColor));
}
output.AddAttribute("title", tb.Start.AddMinutes(userTZ).TimeOfDay.ToString() + " - " + tb.End.AddMinutes(userTZ).ToString());
output.RenderBeginTag("td");
output.RenderEndTag();
output.WriteLine("</tr>");
}
return duration;
}
