Fix Min/Max DateTimeOffset/TimeSpan precision issues

Author: mythz

src/ServiceStack.Text/Common/DateTimeSerializer.cs

@@ -487,13 +487,21 @@ public static string ToShortestXsdDateTimeString(DateTime dateTime)
 
         static readonly char[] TimeZoneChars = new[] { '+', '-' };
 
+        private const string MinDateTimeOffsetWcfValue = "\\/Date(-62135596800000)\\/";
+        private const string MaxDateTimeOffsetWcfValue = "\\/Date(253402300799999)\\/";
+
         /// <summary>
         /// WCF Json format: /Date(unixts+0000)/
         /// </summary>
         /// <param name="wcfJsonDate"></param>
         /// <returns></returns>
         public static DateTimeOffset ParseWcfJsonDateOffset(string wcfJsonDate)
         {
+            if (wcfJsonDate == MinDateTimeOffsetWcfValue)
+                return DateTimeOffset.MinValue;
+            if (wcfJsonDate == MaxDateTimeOffsetWcfValue)
+                return DateTimeOffset.MaxValue;
+            
             if (wcfJsonDate[0] == '\\')
             {
                 wcfJsonDate = wcfJsonDate.Substring(1);
@@ -655,7 +663,7 @@ public static string ToWcfJsonDate(DateTime dateTime)
                 return StringBuilderThreadStatic.ReturnAndFree(sb);
             }
         }
-
+        
         public static void WriteWcfJsonDateTimeOffset(TextWriter writer, DateTimeOffset dateTimeOffset)
         {
             if (JsConfig.DateHandler == DateHandler.ISO8601)

src/ServiceStack.Text/Support/TimeSpanConverter.cs

@@ -6,13 +6,24 @@ namespace ServiceStack.Text.Support
 {
     public class TimeSpanConverter
     {
+        private const string MinSerializedValue = "-P10675199DT2H48M5.4775391S";
+        private const string MaxSerializedValue = "P10675199DT2H48M5.4775391S";
+        
         public static string ToXsdDuration(TimeSpan timeSpan)
         {
+            if (timeSpan == TimeSpan.MinValue)
+                return MinSerializedValue;
+            if (timeSpan == TimeSpan.MaxValue)
+                return MaxSerializedValue;
+            
             var sb = StringBuilderThreadStatic.Allocate();
 
             sb.Append(timeSpan.Ticks < 0 ? "-P" : "P");
 
-            double ticks = timeSpan.Ticks > 0 ? timeSpan.Ticks : timeSpan.Ticks * -1L;
+            double ticks = timeSpan.Ticks;
+            if (ticks < 0)
+                ticks = -ticks;
+
             double totalSeconds = ticks / TimeSpan.TicksPerSecond;
             long wholeSeconds = (long) totalSeconds;
             long seconds = wholeSeconds;
@@ -51,6 +62,11 @@ public static string ToXsdDuration(TimeSpan timeSpan)
 
         public static TimeSpan FromXsdDuration(string xsdDuration)
         {
+            if (xsdDuration == MinSerializedValue)
+                return TimeSpan.MinValue;
+            if (xsdDuration == MaxSerializedValue)
+                return TimeSpan.MaxValue;
+            
             long days = 0;
             long hours = 0;
             long minutes = 0;

tests/ServiceStack.Text.Tests/Issues/SerializationPrecisionIssues.cs

@@ -0,0 +1,62 @@
+using System;
+using NUnit.Framework;
+
+namespace ServiceStack.Text.Tests.Issues
+{
+    public class SerializationPrecisionIssues
+    {
+        public class TimeSpanWrapper
+        {
+            public TimeSpan TimeSpan { get; set; }
+        }
+
+        [Test]
+        public void Can_convert_min_TimeSpan()
+        {
+            var dto = new TimeSpanWrapper {
+                TimeSpan = TimeSpan.MinValue,
+            };
+            var json = JsonSerializer.SerializeToString(dto, typeof(TimeSpanWrapper));
+            var fromJson = JsonSerializer.DeserializeFromString<TimeSpanWrapper>(json);
+            Assert.That(fromJson.TimeSpan, Is.EqualTo(dto.TimeSpan));
+        }
+
+        [Test]
+        public void Can_convert_max_TimeSpan()
+        {
+            var dto = new TimeSpanWrapper {
+                TimeSpan = TimeSpan.MaxValue,
+            };
+            var json = JsonSerializer.SerializeToString(dto, typeof(TimeSpanWrapper));
+            var fromJson = JsonSerializer.DeserializeFromString<TimeSpanWrapper>(json);
+            Assert.That(fromJson.TimeSpan, Is.EqualTo(dto.TimeSpan));
+        }
+
+        class DateTimeOffsetWrapper
+        {
+            public DateTimeOffset DateTimeOffset { get; set; }
+        }
+ 
+        [Test]
+        public void Can_convert_min_DateTimeOffset()
+        {
+            var dto = new DateTimeOffsetWrapper {
+                DateTimeOffset = DateTimeOffset.MinValue,
+            };
+            var json = JsonSerializer.SerializeToString(dto, typeof(DateTimeOffsetWrapper));
+            var fromJson = JsonSerializer.DeserializeFromString<DateTimeOffsetWrapper>(json);
+            Assert.That(fromJson.DateTimeOffset, Is.EqualTo(dto.DateTimeOffset));
+        }
+ 
+        [Test]
+        public void Can_convert_max_DateTimeOffset()
+        {
+            var dto = new DateTimeOffsetWrapper {
+                DateTimeOffset = DateTimeOffset.MaxValue,
+            };
+            var json = JsonSerializer.SerializeToString(dto, typeof(DateTimeOffsetWrapper));
+            var fromJson = JsonSerializer.DeserializeFromString<DateTimeOffsetWrapper>(json);
+            Assert.That(fromJson.DateTimeOffset, Is.EqualTo(dto.DateTimeOffset));
+        }
+    }
+}