ADD : Period & ITimeBlock depuis Lucca

NExtends.Tests/Primitives/DateTimes/PeriodTests.cs

@@ -1,7 +1,5 @@
 using NExtends.Primitives.DateTimes;
 using System;
-using System.Collections.Generic;
-using System.Text;
 using Xunit;
 
 namespace NExtends.Tests.Primitives.DateTimes
@@ -31,5 +29,74 @@ public void PeriodShouldWorkOnDateTimes()
             Assert.Equal(startsAt, period.Start);
             Assert.Equal(endsAt, period.End);
         }
+
+        [Fact]
+        public void PeriodCannotBeNegative()
+        {
+            Assert.Throws<NegativeDurationException>(() =>
+            {
+                var period = new Period(new DateTime(2018, 10, 30), new DateTime(2018, 10, 28));
+            });
+        }
+
+        [Fact]
+        public void PeriodCanBeZeroSize()
+        {
+            var startAndEnd = new DateTime(2018, 10, 30);
+
+            var period = new Period(startAndEnd, startAndEnd);
+        }
+
+        [Fact]
+        public void ITimeBlockEndCannotBeModifiedToBeNegative()
+        {
+            var startAndEnd = new DateTime(2018, 10, 30);
+
+            ITimeBlock period = new Period(startAndEnd, startAndEnd);
+
+            Assert.Throws<NegativeDurationException>(() =>
+            {
+                period.ChangeEndsAt(new DateTime(2018, 10, 28));
+            });
+        }
+
+        [Fact]
+        public void ITimeBlockStartCannotBeModifiedToBeNegative()
+        {
+            var startAndEnd = new DateTime(2018, 10, 28);
+
+            ITimeBlock period = new Period(startAndEnd, startAndEnd);
+
+            Assert.Throws<NegativeDurationException>(() =>
+            {
+                period.ChangeStartsAt(new DateTime(2018, 10, 30));
+            });
+        }
+
+        [Fact]
+        public void ITimeBlockDurationCannotBeModifiedToBeNegative()
+        {
+            var startAndEnd = new DateTime(2018, 10, 28);
+
+            ITimeBlock period = new Period(startAndEnd, startAndEnd);
+
+            Assert.Throws<NegativeDurationException>(() =>
+            {
+                period.ChangeDuration(TimeSpan.FromSeconds(-1));
+            });
+        }
+
+        [Fact]
+        public void ITimeBlockDurationCanBeDifferentFromEndMinusStart()
+        {
+            var startAndEnd = new DateTime(2018, 10, 28);
+
+            ITimeBlock period = new Period(startAndEnd, startAndEnd);
+
+            period.ChangeDuration(TimeSpan.FromSeconds(1));
+
+            Assert.Equal(TimeSpan.FromSeconds(1), period.Duration);
+            Assert.Equal(TimeSpan.FromSeconds(0), period.EndsAt - period.StartsAt);
+        }
     }
 }

NExtends.Tests/Primitives/Strings/StringExtensionsTests.cs

@@ -67,6 +67,7 @@ public void ContainsIgnoreCaseShouldWork(string match, string chain)
             Assert.True(result);
         }
 
+        [Theory]
         [InlineData("toto")]
         [InlineData(null)]
         [InlineData("")]

NExtends.Tests/Primitives/TimeSpans/TimeSpan.extensions.tests.cs

@@ -1,5 +1,6 @@
 using NExtends.Primitives.TimeSpans;
 using System;
+using System.Globalization;
 using Xunit;
 
 namespace NExtends.Tests.Primitives.TimeSpans
@@ -20,10 +21,10 @@ public void TimespanMultiply()
         [Theory]
         [InlineData(0, true, "-")]
         [InlineData(0, false, "-")]
-        [InlineData(9, true, "+09mn")]
-        [InlineData(9, false, "09mn")]
-        [InlineData(-9, true, "-09mn")]
-        [InlineData(-9, false, "-09mn")]
+        [InlineData(9, true, "+09m")]
+        [InlineData(9, false, "09m")]
+        [InlineData(-9, true, "-09m")]
+        [InlineData(-9, false, "-09m")]
         [InlineData(69, true, "+1h09")]
         [InlineData(69, false, "1h09")]
         [InlineData(-69, true, "-1h09")]
@@ -32,8 +33,8 @@ public void TimespanMultiply()
         public void TimeSpanToHoursShouldWork(int timeInMinutes, bool showSign, string expected)
         {
             var timespan = TimeSpan.FromMinutes(timeInMinutes);
-            var initials = new TimeInitials("mn", "h", "j");
-            var result = TimeSpanExtensions.ToHours(timespan, initials, showSign);
+            var culture = CultureInfo.GetCultureInfo("fr-FR");
+            var result = TimeSpanExtensions.ToHours(timespan, culture, showSign);
 
             Assert.Equal(expected, result);
         }
@@ -53,8 +54,8 @@ public void TimeSpanToHoursShouldWork(int timeInMinutes, bool showSign, string e
         public void TimeSpanToDaysShouldWork(int timeInMinutes, bool showSign, string expected)
         {
             var timespan = TimeSpan.FromMinutes(timeInMinutes);
-            var initials = new TimeInitials("mn", "h", "j");
-            var result = TimeSpanExtensions.ToDays(timespan, initials, showSign);
+            var culture = CultureInfo.GetCultureInfo("fr-FR");
+            var result = TimeSpanExtensions.ToDays(timespan, culture, showSign);
 
             Assert.Equal(expected, result);
         }

NExtends/Primitives/DateTimes/ITimeBlock.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace NExtends.Primitives.DateTimes
+{
+    public interface ITimeBlock
+    {
+        DateTime StartsAt { get; }
+        DateTime EndsAt { get; }
+        TimeSpan Duration { get; }
+
+        void ChangeStartsAt(DateTime startsAt);
+        void ChangeEndsAt(DateTime endsAt);
+        void ChangeDuration(TimeSpan duration);
+    }
+}

NExtends/Primitives/DateTimes/NegativeDurationException.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Runtime.Serialization;
+
+namespace NExtends.Primitives.DateTimes
+{
+    [Serializable]
+    public class NegativeDurationException : ArgumentException
+    {
+        protected NegativeDurationException(SerializationInfo info, StreamingContext context)
+            : base(info, context) { }
+
+        public NegativeDurationException(string paramName)
+            : base("You cannot create or update a period to a negative duration", paramName) { }
+    }
+}

NExtends/Primitives/DateTimes/Period.cs

@@ -2,16 +2,82 @@
 
 namespace NExtends.Primitives.DateTimes
 {
-    public struct Period
+    public class Period : ITimeBlock, IEquatable<Period>
     {
-        public DateTime Start { get; }
-        public DateTime End { get; }
-        public TimeSpan Duration { get { return End - Start; } }
+        public DateTime Start { get; private set; }
+        public DateTime End { get; private set; }
+        public TimeSpan Duration { get; private set; }
+
+        public DateTime StartsAt => Start;
+        public DateTime EndsAt => End;
+
+        void ITimeBlock.ChangeStartsAt(DateTime startsAt)
+        {
+            if (startsAt > End)
+            {
+                throw new NegativeDurationException(nameof(startsAt));
+            }
+
+            Start = startsAt;
+        }
+        void ITimeBlock.ChangeEndsAt(DateTime endsAt)
+        {
+            if (endsAt < Start)
+            {
+                throw new NegativeDurationException(nameof(endsAt));
+            }
+
+            End = endsAt;
+        }
+        void ITimeBlock.ChangeDuration(TimeSpan duration)
+        {
+            if (duration < TimeSpan.Zero)
+            {
+                throw new NegativeDurationException(nameof(duration));
+            }
+
+            Duration = duration;
+        }
 
         public Period(DateTime start, DateTime end)
         {
             Start = start;
             End = end;
+            Duration = end - start;
+
+            if (Duration < TimeSpan.Zero)
+            {
+                throw new NegativeDurationException(nameof(end));
+            }
+        }
+
+        public virtual bool Equals(Period other)
+        {
+            if (other == null) { return false; }
+
+            return Start == other.Start &&
+                End == other.End &&
+                Duration == other.Duration;
+        }
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) { return false; }
+            if (ReferenceEquals(this, obj)) { return true; }
+            if (obj.GetType() != GetType()) { return false; }
+
+            return Equals(obj as Period);
+        }
+        public override int GetHashCode()
+        {
+            //cf http://www.aaronstannard.com/overriding-equality-in-dotnet/
+            unchecked
+            {
+                var hashCode = 13;
+                hashCode = (hashCode * 397) ^ Start.GetHashCode();
+                hashCode = (hashCode * 397) ^ End.GetHashCode();
+                hashCode = (hashCode * 397) ^ Duration.GetHashCode();
+                return hashCode;
+            }
         }
     }
 }

NExtends/Primitives/TimeSpans/TimeInitials.cs

@@ -1,7 +1,13 @@
-namespace NExtends.Primitives.TimeSpans
+using System.Globalization;
+
+namespace NExtends.Primitives.TimeSpans
 {
     public class TimeInitials
     {
+        private static readonly TimeInitials _french = new TimeInitials("m", "h", "j");
+        private static readonly TimeInitials _german = new TimeInitials("M", "St", "T");
+        private static readonly TimeInitials _english = new TimeInitials("m", "h", "d");
+
         public string MinutesInitial { get; }
         public string HoursInitial { get; }
         public string DaysInitial { get; }
@@ -12,5 +18,18 @@ public TimeInitials(string minutesInitial, string hoursInitial, string daysIniti
             HoursInitial = hoursInitial;
             DaysInitial = daysInitial;
         }
+
+        public static TimeInitials FromCulture(CultureInfo culture)
+        {
+            switch(culture.Name)
+            {
+                case "fr-FR":
+                    return _french;
+                case "de-DE":
+                    return _german;
+                default:
+                    return _english;
+            }
+        }
     }
 }

NExtends/Primitives/TimeSpans/TimeSpan.extensions.cs

@@ -46,29 +46,39 @@ public static TimeSpan Sum<TSource>(this IEnumerable<TSource> source, Func<TSour
 		public static bool IsNegativeOrZero(this TimeSpan t1) { return t1.Ticks <= 0; }
 		public static bool IsNegative(this TimeSpan t1) { return t1.Ticks < 0; }
 
-        public static string Humanize(this TimeSpan timeSpan, TimeUnit timeUnit, TimeInitials initials, bool showSign = false)
+        public static string Humanize(this TimeSpan timeSpan, TimeUnit timeUnit, bool showSign = false)
+        {
+            return Humanize(timeSpan, timeUnit, CultureInfo.CurrentCulture, showSign);
+        }
+        public static string Humanize(this TimeSpan timeSpan, TimeUnit timeUnit, CultureInfo culture, bool showSign = false)
         {
             switch (timeUnit)
             {
                 case TimeUnit.Day:
-                    return ToDays(timeSpan, initials, showSign);
+                    return ToDays(timeSpan, culture, showSign);
                 case TimeUnit.Duration:
                 case TimeUnit.Time:
-                    return ToHours(timeSpan, initials, showSign);
+                    return ToHours(timeSpan, culture, showSign);
                 case TimeUnit.NotApplicable:
                 default:
                     throw new InvalidEnumArgumentException(nameof(timeUnit));
             }
         }
 
-        public static string ToHours(this TimeSpan timeSpan, TimeInitials initials, bool showSign = false)
+        public static string ToHours(this TimeSpan timeSpan, bool showSign = false)
+        {
+            return ToHours(timeSpan, CultureInfo.CurrentCulture, showSign);
+        }
+        public static string ToHours(this TimeSpan timeSpan, CultureInfo culture, bool showSign = false)
         {
             if (timeSpan == TimeSpan.Zero)
             {
                 return "-";
             }
+
             var absSpan = new TimeSpan(Math.Abs(timeSpan.Ticks));
             var totalHours = Math.Floor(absSpan.TotalHours);
+            var initials = TimeInitials.FromCulture(culture);
 
             var sb = new StringBuilder();
             if (showSign && timeSpan > TimeSpan.Zero)
@@ -91,17 +101,26 @@ public static string ToHours(this TimeSpan timeSpan, TimeInitials initials, bool
             {
                 sb.Append(initials.MinutesInitial);
             }
+
             return sb.ToString();
         }
 
-        public static string ToDays(this TimeSpan span, TimeInitials initials, bool showSign = false)
+        public static string ToDays(this TimeSpan span, bool showSign = false)
+        {
+            return ToDays(span, CultureInfo.CurrentCulture, showSign);
+        }
+
+        public static string ToDays(this TimeSpan span, CultureInfo culture, bool showSign = false)
         {
             if (span == TimeSpan.Zero)
             {
                 return "-";
             }
+
             var absSpan = new TimeSpan(Math.Abs(span.Ticks));
             var sb = new StringBuilder();
+            var initials = TimeInitials.FromCulture(culture);
+
             if (showSign && span > TimeSpan.Zero)
             {
                 sb.Append("+");
@@ -110,7 +129,9 @@ public static string ToDays(this TimeSpan span, TimeInitials initials, bool show
             {
                 sb.Append("-");
             }
+
             sb.AppendFormat(CultureInfo.InvariantCulture, "{0} " + initials.DaysInitial, absSpan.TotalDays.RealRound(5));
+
             return sb.ToString();
         }
     }