Merge pull request #277 from DougSchmidt-AI/feature/PF-1205-PointZillaNotes

PF-1205 - Added proper note-combining logic

Author: Doug Schmidt

TimeSeries/PublicApis/SdkExamples/PointZilla/IntervalExtensions.cs

@@ -0,0 +1,30 @@
+using NodaTime;
+
+namespace PointZilla
+{
+    public static class IntervalExtensions
+    {
+        public static bool Intersects(this Interval interval1, Interval interval2)
+        {
+            return !interval1.Disjoint(interval2);
+        }
+
+        public static bool Intersects(this Interval? interval1, Interval? interval2)
+        {
+            return interval1.HasValue && interval2.HasValue && interval1.Value.Intersects(interval2.Value);
+        }
+
+        private static bool Disjoint(this Interval interval1, Interval interval2)
+        {
+            return interval1.IsEmpty() ||
+                   interval2.IsEmpty() ||
+                   interval1.End <= interval2.Start ||
+                   interval2.End <= interval1.Start;
+        }
+
+        public static bool IsEmpty(this Interval interval)
+        {
+            return interval.Start.Equals(interval.End);
+        }
+    }
+}

TimeSeries/PublicApis/SdkExamples/PointZilla/PointZilla.csproj

@@ -161,6 +161,7 @@
     <Compile Include="CommandType.cs" />
     <Compile Include="Context.cs" />
     <Compile Include="CreateMode.cs" />
+    <Compile Include="IntervalExtensions.cs" />
     <Compile Include="PointReaders\CsvNotesReader.cs" />
     <Compile Include="PointReaders\CsvReader.cs" />
     <Compile Include="CsvWriter.cs" />

TimeSeries/PublicApis/SdkExamples/PointZilla/PointsAppender.cs

@@ -33,8 +33,7 @@ public void AppendPoints()
 
             (Points, Notes) = GetPoints();
 
-            if (Context.IgnoreNotes)
-                Notes.Clear();
+            AdjustNotes();
 
             if (Points.All(p => p.Type != PointType.Gap))
             {
@@ -140,6 +139,81 @@ public void AppendPoints()
             }
         }
 
+        private void AdjustNotes()
+        {
+            if (Context.IgnoreNotes)
+            {
+                Notes.Clear();
+                return;
+            }
+
+            var noteCombiner = new NoteCombiner();
+
+            foreach (var note in Notes
+                .Select(AdjustNoteTextAndTimeRange)
+                .OrderBy(note => note.TimeRange?.Start)
+                .ThenByDescending(note => note.TimeRange?.End))
+            {
+                noteCombiner.AddOverlappingIntervalMetadata(note, (note1, note2) => note1.NoteText != note2.NoteText);
+            }
+
+            Notes = noteCombiner.Items;
+        }
+
+        private TimeSeriesNote AdjustNoteTextAndTimeRange(TimeSeriesNote note)
+        {
+            if (note.TimeRange.HasValue && note.TimeRange.Value.End == note.TimeRange.Value.Start)
+            {
+                note.TimeRange = new Interval(note.TimeRange.Value.Start, note.TimeRange.Value.End.PlusTicks(1));
+            }
+
+            const int maxNoteLength = 500;
+
+            if (note.NoteText.Length > maxNoteLength)
+            {
+                note.NoteText = note.NoteText.Substring(0, maxNoteLength - 20) + " ... note truncated.";
+            }
+
+            return note;
+        }
+
+        private class NoteCombiner
+        {
+            public List<TimeSeriesNote> Items { get; } = new List<TimeSeriesNote>();
+
+            private TimeSeriesNote CurrentItem { get; set; }
+
+            public void AddOverlappingIntervalMetadata(
+                TimeSeriesNote newItem,
+                Func<TimeSeriesNote, TimeSeriesNote, bool> isDifferent)
+            {
+                var overlappingItem = Items
+                    .LastOrDefault(item => item.TimeRange.Intersects(newItem.TimeRange) && !isDifferent(item, newItem));
+
+                if (overlappingItem == null)
+                {
+                    CurrentItem = newItem;
+                    Items.Add(CurrentItem);
+
+                    return;
+                }
+
+                CurrentItem = overlappingItem;
+
+                ExtendCurrentItem(newItem.TimeRange);
+            }
+
+            private void ExtendCurrentItem(Interval? timeRange)
+            {
+                if (!timeRange.HasValue || !CurrentItem.TimeRange.HasValue)
+                    return;
+
+                CurrentItem.TimeRange = new Interval(
+                    Instant.Min(CurrentItem.TimeRange.Value.Start, timeRange.Value.Start),
+                    Instant.Max(CurrentItem.TimeRange.Value.End, timeRange.Value.End));
+            }
+        }
+
         private IAquariusClient CreateConnectedClient()
         {
             return string.IsNullOrWhiteSpace(Context.SessionToken)
@@ -184,57 +258,15 @@ private int AppendNotes(IAquariusClient client, TimeSeries timeSeries)
             if (client.ServerVersion.IsLessThan(MinimumNotesVersion))
                 throw new ExpectedException($"You can't append time-series notes before AQTS v{MinimumNotesVersion}");
 
-            var notes = CoalesceAdjacentNotes(Notes)
-                    .Select(note =>
-                    {
-                        const int maxNoteLength = 500;
-
-                        if (note.NoteText.Length > maxNoteLength)
-                        {
-                            note.NoteText = note.NoteText.Substring(0, maxNoteLength - 20) + " ... note truncated.";
-                        }
-
-                        return note;
-                    })
-                .ToList();
-
             return client.Acquisition.Post(new PostTimeSeriesMetadata
             {
                 UniqueId = timeSeries.UniqueId,
-                Notes = notes
+                Notes = Notes
             }).NotesCreated;
         }
 
         private static readonly AquariusServerVersion MinimumNotesVersion = AquariusServerVersion.Create("19.2.185");
 
-        private IEnumerable<TimeSeriesNote> CoalesceAdjacentNotes(IEnumerable<TimeSeriesNote> notes)
-        {
-            TimeSeriesNote previousNote = null;
-
-            foreach (var note in notes
-                .OrderBy(note => note.TimeRange?.Start)
-                .ThenBy(note => note.TimeRange?.End))
-            {
-                if (previousNote != null)
-                {
-                    if (previousNote.TimeRange?.End == note.TimeRange?.Start && previousNote.NoteText == note.NoteText)
-                    {
-                        previousNote.TimeRange = new Interval(
-                            previousNote.TimeRange?.Start ?? throw new ExpectedException("Invalid TimeRange Start value"),
-                            note.TimeRange?.End ?? throw new ExpectedException("Invalid TimeRange End value"));
-                        continue;
-                    }
-
-                    yield return previousNote;
-                }
-
-                previousNote = note;
-            }
-
-            if (previousNote != null)
-                yield return previousNote;
-        }
-
         private TimeSeriesAppendStatus AppendPointBatch(IAquariusClient client, TimeSeries timeSeries, List<TimeSeriesPoint> points, Interval timeRange, bool isReflected, bool hasTimeRange)
         {
             AppendResponse appendResponse;