Creation of ADO Connection

Adaptation/FileHandlers/json/WorkItems/Record.cs

@@ -1,27 +1,163 @@
+using System;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text.Json.Serialization;
 
 namespace Adaptation.FileHandlers.json.WorkItems;
 
-public class Record
+internal class Record
 {
 
 #nullable enable
 
     [JsonConstructor]
-    public Record(WorkItem workItem, WorkItem? parent, Record[] children)
+    public Record(WorkItem workItem, WorkItem? parent, Record[] children, Record[] related, Record[] successors)
     {
         WorkItem = workItem;
         Parent = parent;
         Children = children;
+        Related = related;
+        Successors = successors;
     }
 
-    public WorkItem WorkItem { get; set; }
-    public WorkItem? Parent { get; set; }
-    public Record[] Children { get; set; }
+    [JsonPropertyName("WorkItem")] public WorkItem WorkItem { get; set; }
+    [JsonPropertyName("Parent")] public WorkItem? Parent { get; set; }
+    [JsonPropertyName("Children")] public Record[] Children { get; set; }
+    [JsonPropertyName("Related")] public Record[] Related { get; set; }
+    [JsonPropertyName("Successors")] public Record[] Successors { get; set; }
 
-    public static Record Get(WorkItem workItem, WorkItem? parent, ReadOnlyCollection<Record> children) =>
-        new(workItem, parent, children.ToArray());
+    internal static Record GetWithoutNesting(Record record, string? violation)
+    {
+        Record result;
+        WorkItem workItem = new(record.WorkItem.ActivatedDate,
+                                record.WorkItem.AreaPath,
+                                record.WorkItem.AssignedTo,
+                                record.WorkItem.BusinessValue,
+                                record.WorkItem.ChangedDate,
+                                record.WorkItem.ClosedDate,
+                                record.WorkItem.CommentCount,
+                                record.WorkItem.CreatedDate,
+                                record.WorkItem.Description,
+                                record.WorkItem.Effort,
+                                record.WorkItem.Id,
+                                record.WorkItem.IterationPath,
+                                record.WorkItem.Parent,
+                                record.WorkItem.Priority,
+                                record.WorkItem.Relations,
+                                record.WorkItem.Requester,
+                                record.WorkItem.ResolvedDate,
+                                record.WorkItem.Revision,
+                                record.WorkItem.RiskReductionMinusOpportunityEnablement,
+                                record.WorkItem.StartDate,
+                                record.WorkItem.State,
+                                record.WorkItem.Tags,
+                                record.WorkItem.TargetDate,
+                                record.WorkItem.TimeCriticality,
+                                record.WorkItem.Title,
+                                record.WorkItem.Violation is null ? violation : record.WorkItem.Violation,
+                                record.WorkItem.WeightedShortestJobFirst,
+                                record.WorkItem.WorkItemType);
+        result = new(workItem, record.Parent, Array.Empty<Record>(), Array.Empty<Record>(), Array.Empty<Record>());
+        return result;
+    }
 
+    private static Record Get(Record record, bool keepRelations)
+    {
+        Record result;
+        WorkItem? parentWorkItem = keepRelations ? record.Parent : WorkItem.GetWithOutRelations(record.Parent);
+        WorkItem? workItem = keepRelations ? record.WorkItem : WorkItem.GetWithOutRelations(record.WorkItem) ?? throw new Exception();
+        List<Record> childRecords = new();
+        List<Record> relatedRecords = new();
+        List<Record> successorRecords = new();
+        foreach (Record r in record.Children)
+            childRecords.Add(Get(r, keepRelations));
+        foreach (Record r in record.Related)
+            relatedRecords.Add(Get(r, keepRelations));
+        foreach (Record r in record.Successors)
+            successorRecords.Add(Get(r, keepRelations));
+        result = new(workItem, parentWorkItem, childRecords.ToArray(), relatedRecords.ToArray(), successorRecords.ToArray());
+        return result;
+    }
+
+    internal static Record Get(WorkItem workItem, WorkItem? parent, ReadOnlyCollection<Record> children, ReadOnlyCollection<Record> related, ReadOnlyCollection<Record> successors, bool keepRelations)
+    {
+        Record result;
+        Record record = new(workItem, parent, children.ToArray(), related.ToArray(), successors.ToArray());
+        result = Get(record, keepRelations);
+        return result;
+    }
+
+    private static int? GetIdFromUrl(string relationName, Relation relation)
+    {
+        int? result;
+        string[] segments = relation?.Attributes is null || relation.Attributes.Name != relationName ? Array.Empty<string>() : relation.URL.Split('/');
+        if (segments.Length < 2)
+            result = null;
+        else
+        {
+            if (!int.TryParse(segments[segments.Length - 1], out int id))
+                result = null;
+            else
+                result = id;
+        }
+        return result;
+    }
+
+    internal static ReadOnlyCollection<Record> GetKeyValuePairs(ReadOnlyDictionary<int, WorkItem> keyValuePairs, WorkItem workItem, string relationName, List<bool> nests, bool keepRelations)
+    {
+        List<Record> results = new();
+        int? childId;
+        Record record;
+        nests.Add(true);
+        WorkItem? childWorkItem;
+        WorkItem? parentWorkItem;
+        List<WorkItem> collection = new();
+        ReadOnlyCollection<Record> childRecords;
+        ReadOnlyCollection<Record> relatedRecords;
+        ReadOnlyCollection<Record> successorRecords;
+        if (workItem.Relations is not null && workItem.Relations.Length > 0)
+        {
+            collection.Clear();
+            foreach (Relation relation in workItem.Relations)
+            {
+                childId = GetIdFromUrl(relationName, relation);
+                if (childId is not null && workItem.Parent is not null && relation?.URL is not null && relation.URL.Contains(workItem.Parent.Value.ToString()))
+                    continue;
+                if (childId is null || !keyValuePairs.TryGetValue(childId.Value, out childWorkItem))
+                    continue;
+                collection.Add(childWorkItem);
+            }
+            collection = (from l in collection orderby l.State != "Closed", l.Id select l).ToList();
+            foreach (WorkItem w in collection)
+            {
+                if (nests.Count > 99)
+                    break;
+                if (w.Parent is null)
+                    parentWorkItem = null;
+                else
+                    _ = keyValuePairs.TryGetValue(w.Parent.Value, out parentWorkItem);
+                childRecords = GetKeyValuePairs(keyValuePairs, w, "Child", nests, keepRelations); // Forward
+                // records = GetKeyValuePairs(keyValuePairs, w, "Predecessor", nests); // Reverse
+                // successorRecords = GetKeyValuePairs(keyValuePairs, w, "Successor", nests); // Forward
+                // if (successorRecords.Count > 0)
+                // {
+                //     if (successorRecords.Count > 0)
+                //     { }
+                // }
+                successorRecords = new(Array.Empty<Record>());
+                relatedRecords = GetKeyValuePairs(keyValuePairs, w, "Related", nests, keepRelations); // Related
+                record = Get(w, parentWorkItem, childRecords, relatedRecords, successorRecords, keepRelations);
+                results.Add(record);
+            }
+        }
+        return new(results);
+    }
+
+}
+
+[JsonSourceGenerationOptions(WriteIndented = true)]
+[JsonSerializable(typeof(Record))]
+internal partial class RecordSourceGenerationContext : JsonSerializerContext
+{
 }