Created tests

Adaptation/FileHandlers/Markdown/ProcessData.cs

@@ -0,0 +1,723 @@
+using Adaptation.FileHandlers.json.WorkItems;
+using Adaptation.Shared;
+using Adaptation.Shared.Duplicator;
+using Adaptation.Shared.Methods;
+using log4net;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Adaptation.FileHandlers.Markdown;
+
+public class ProcessData : IProcessData
+{
+
+    private readonly List<object> _Details;
+
+    List<object> Shared.Properties.IProcessData.Details => _Details;
+
+    private readonly ILog _Log;
+
+    public ProcessData(IFileRead fileRead, Logistics logistics, string targetFileLocation, string url, ReadOnlyCollection<string> workItemTypes, List<FileInfo> fileInfoCollection)
+    {
+        if (fileRead.IsEAFHosted)
+        { }
+        fileInfoCollection.Clear();
+        _Details = new List<object>();
+        _Log = LogManager.GetLogger(typeof(ProcessData));
+        WriteFiles(fileRead, logistics, url, workItemTypes, targetFileLocation, fileInfoCollection);
+    }
+
+    string IProcessData.GetCurrentReactor(IFileRead fileRead, Logistics logistics, Dictionary<string, string> reactors) =>
+        throw new Exception(string.Concat("See ", nameof(WriteFiles)));
+
+    Tuple<string, Test[], JsonElement[], List<FileInfo>> IProcessData.GetResults(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection) =>
+        new(logistics.Logistics1[0], Array.Empty<Test>(), Array.Empty<JsonElement>(), fileInfoCollection);
+
+#nullable enable
+
+    internal static List<Description> GetDescriptions(JsonElement[] jsonElements)
+    {
+        List<Description> results = new();
+        Description? description;
+        JsonSerializerOptions jsonSerializerOptions = new() { NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString };
+        foreach (JsonElement jsonElement in jsonElements)
+        {
+            if (jsonElement.ValueKind != JsonValueKind.Object)
+                throw new Exception();
+            description = JsonSerializer.Deserialize<Description>(jsonElement.ToString(), jsonSerializerOptions);
+            if (description is null)
+                continue;
+            results.Add(description);
+        }
+        return results;
+    }
+
+    private void WriteFiles(IFileRead fileRead, Logistics logistics, string url, ReadOnlyCollection<string> workItemTypes, string destinationDirectory, List<FileInfo> fileInfoCollection)
+    {
+        string json = File.ReadAllText(logistics.ReportFullPath);
+        WorkItem[]? workItems = JsonSerializer.Deserialize<WorkItem[]>(json);
+        if (workItems is null)
+            throw new Exception(nameof(workItems));
+        List<char> spaces = new();
+        List<string> lines = new();
+        ReadOnlyCollection<WorkItem> results;
+        ReadOnlyDictionary<int, Record> keyValuePairs = GetWorkItems(workItems);
+        WriteFileStructure(destinationDirectory, keyValuePairs);
+        ReadOnlyCollection<Record> records = new(keyValuePairs.Values.ToArray());
+        ReadOnlyCollection<string> bugUserStoryWorkItemTypes = new(new string[] { "Bug", "User Story" });
+        ReadOnlyCollection<string> bugUserStoryTaskWorkItemTypes = new(new string[] { "Bug", "User Story", "Task" });
+        if (!Directory.Exists(destinationDirectory))
+            _ = Directory.CreateDirectory(destinationDirectory);
+        WriteFiles(fileRead, destinationDirectory, fileInfoCollection, records, "with-parents");
+        foreach (string workItemType in workItemTypes)
+        {
+            lines.Clear();
+            lines.Add($"# {workItemType}");
+            lines.Add(string.Empty);
+            AppendLines(url, spaces, lines, records, workItemType);
+            results = new(Array.Empty<WorkItem>());
+            WriteFiles(fileRead, destinationDirectory, fileInfoCollection, new(lines), results, workItemType);
+            _Details.Add(results);
+        }
+        {
+            lines.Clear();
+            string workItemType = "Feature";
+            lines.Add($"# {nameof(FeatureCheckIterationPath122508)}");
+            lines.Add(string.Empty);
+            results = FeatureCheckIterationPath122508(url, lines, bugUserStoryTaskWorkItemTypes, records, workItemType);
+            WriteFiles(fileRead, destinationDirectory, fileInfoCollection, new(lines), results, "check-122508");
+            _Details.Add(results);
+        }
+        {
+            lines.Clear();
+            string workItemType = "Feature";
+            lines.Add($"# {nameof(FeatureCheckTag122514)}");
+            lines.Add(string.Empty);
+            results = FeatureCheckTag122514(url, lines, bugUserStoryWorkItemTypes, records, workItemType);
+            WriteFiles(fileRead, destinationDirectory, fileInfoCollection, new(lines), results, "check-122514");
+            _Details.Add(results);
+        }
+        {
+            lines.Clear();
+            string workItemType = "Feature";
+            lines.Add($"# {nameof(FeatureCheckPriority126169)}");
+            lines.Add(string.Empty);
+            results = FeatureCheckPriority126169(url, lines, bugUserStoryWorkItemTypes, records, workItemType);
+            WriteFiles(fileRead, destinationDirectory, fileInfoCollection, new(lines), results, "check-126169");
+            _Details.Add(results);
+        }
+        {
+            lines.Clear();
+            string workItemType = "Feature";
+            lines.Add($"# {nameof(FeatureCheckState123066)}");
+            lines.Add(string.Empty);
+            results = FeatureCheckState123066(url, lines, bugUserStoryTaskWorkItemTypes, records, workItemType);
+            WriteFiles(fileRead, destinationDirectory, fileInfoCollection, new(lines), results, "check-123066");
+            _Details.Add(results);
+        }
+        {
+            lines.Clear();
+            string workItemType = "Feature";
+            lines.Add($"# {nameof(FeatureCheckState123067)}");
+            lines.Add(string.Empty);
+            results = FeatureCheckState123067(url, lines, bugUserStoryTaskWorkItemTypes, records, workItemType);
+            WriteFiles(fileRead, destinationDirectory, fileInfoCollection, new(lines), results, "check-123067");
+            _Details.Add(results);
+        }
+    }
+
+    private static void WriteFiles(IFileRead fileRead, string destinationDirectory, List<FileInfo> fileInfoCollection, ReadOnlyCollection<string> lines, ReadOnlyCollection<WorkItem> workItems, string fileName)
+    {
+        string markdown = string.Join(Environment.NewLine, lines);
+        string markdownFile = Path.Combine(destinationDirectory, $"{fileName}.md");
+        string markdownOld = !File.Exists(markdownFile) ? string.Empty : File.ReadAllText(markdownFile);
+        if (markdown != markdownOld)
+            File.WriteAllText(markdownFile, markdown);
+        if (!fileRead.IsEAFHosted)
+            fileInfoCollection.Add(new(markdownFile));
+        string html = CommonMark.CommonMarkConverter.Convert(markdown).Replace("<a href", "<a target='_blank' href");
+        string htmlFile = Path.Combine(destinationDirectory, $"{fileName}.html");
+        string htmlOld = !File.Exists(htmlFile) ? string.Empty : File.ReadAllText(htmlFile);
+        if (html != htmlOld)
+            File.WriteAllText(htmlFile, html);
+        if (!fileRead.IsEAFHosted)
+            fileInfoCollection.Add(new(htmlFile));
+        string json = JsonSerializer.Serialize(workItems, new JsonSerializerOptions() { WriteIndented = true });
+        string jsonFile = Path.Combine(destinationDirectory, $"{fileName}.json");
+        string jsonOld = !File.Exists(jsonFile) ? string.Empty : File.ReadAllText(jsonFile);
+        if (json != jsonOld)
+            File.WriteAllText(jsonFile, json);
+        if (!fileRead.IsEAFHosted)
+            fileInfoCollection.Add(new(jsonFile));
+    }
+
+    private static ReadOnlyDictionary<int, Record> GetWorkItems(WorkItem[] workItems)
+    {
+        ReadOnlyDictionary<int, Record> results;
+        Dictionary<int, WorkItem> keyValuePairs = new();
+        foreach (WorkItem workItem in workItems)
+            keyValuePairs.Add(workItem.Id, workItem);
+        results = GetKeyValuePairs(new(keyValuePairs));
+        return results;
+    }
+
+    private static void WriteFileStructure(string destinationDirectory, ReadOnlyDictionary<int, Record> keyValuePairs)
+    {
+        ReadOnlyCollection<string> collection = GetDirectories(destinationDirectory, keyValuePairs);
+        foreach (string directory in collection)
+        {
+            if (directory.Length > 222)
+                continue;
+            if (!Directory.Exists(directory))
+                _ = Directory.CreateDirectory(directory);
+        }
+    }
+
+    private static void WriteFiles(IFileRead fileRead, string destinationDirectory, List<FileInfo> fileInfoCollection, ReadOnlyCollection<Record> records, string fileName)
+    {
+        string json = JsonSerializer.Serialize(records, new JsonSerializerOptions() { WriteIndented = true });
+        string jsonFile = Path.Combine(destinationDirectory, $"{fileName}.json");
+        string jsonOld = !File.Exists(jsonFile) ? string.Empty : File.ReadAllText(jsonFile);
+        if (json != jsonOld)
+            File.WriteAllText(jsonFile, json);
+        if (!fileRead.IsEAFHosted)
+            fileInfoCollection.Add(new(jsonFile));
+    }
+
+    private static void AppendLines(string url, List<char> spaces, List<string> lines, ReadOnlyCollection<Record> records, string workItemType)
+    {
+        List<string> results = new();
+        string? maxIterationPath;
+        List<string> distinct = new();
+        foreach (Record record in records)
+        {
+            // if (record.WorkItem.Id != 109724)
+            //     continue;
+            if (record.WorkItem.WorkItemType != workItemType)
+                continue;
+            results.Add($"## {record.WorkItem.AssignedTo} - {record.WorkItem.Id} - {record.WorkItem.Title}");
+            results.Add(string.Empty);
+            results.Add($"- [{record.WorkItem.Id}]({url}{record.WorkItem.Id})");
+            if (record.Children.Count == 0)
+                results.Add(string.Empty);
+            else
+            {
+                AppendLines(spaces, results, record, condensed: true, sprintOnly: false);
+                results.Add(string.Empty);
+                distinct.Clear();
+                AppendLines(spaces, distinct, record, condensed: false, sprintOnly: true);
+                if (distinct.Count > 1)
+                {
+                    results.Add($"## Distinct Iteration Path(s) - {record.WorkItem.WorkItemType} - {record.WorkItem.AssignedTo} - {record.WorkItem.Id} - {record.WorkItem.Title} - {record.WorkItem.IterationPath}");
+                    results.Add(string.Empty);
+                    results.Add($"- [{record.WorkItem.Id}]({url}{record.WorkItem.Id})");
+                    distinct.Sort();
+                    distinct = (from l in distinct select l.Trim()).Distinct().ToList();
+                    results.AddRange(distinct);
+                    results.Add(string.Empty);
+                    maxIterationPath = distinct.Max();
+                    if (!string.IsNullOrEmpty(maxIterationPath) && maxIterationPath.Contains("] ") && maxIterationPath.Split(']')[1].Trim() != record.WorkItem.IterationPath)
+                    {
+                        results.Add($"### Sync to Distinct Max Iteration Path => {maxIterationPath} - {record.WorkItem.Id} - {record.WorkItem.Title}");
+                        results.Add(string.Empty);
+                    }
+                }
+                results.Add($"## Extended - {record.WorkItem.Id} - {record.WorkItem.Title}");
+                results.Add(string.Empty);
+                AppendLines(spaces, results, record, condensed: false, sprintOnly: false);
+                results.Add(string.Empty);
+            }
+            lines.AddRange(results);
+            results.Clear();
+        }
+    }
+
+    private static void AppendLines(List<char> spaces, List<string> lines, Record record, bool condensed, bool sprintOnly)
+    {
+        string line;
+        spaces.Add('\t');
+        WorkItem workItem;
+        foreach (Record child in record.Children)
+        {
+            workItem = child.WorkItem;
+            line = GetLine(spaces, workItem, child, condensed, sprintOnly).TrimEnd();
+            lines.Add(line);
+            AppendLines(spaces, lines, child, condensed, sprintOnly);
+        }
+        spaces.RemoveAt(0);
+    }
+
+    private static ReadOnlyDictionary<int, Record> GetKeyValuePairs(ReadOnlyDictionary<int, WorkItem> keyValuePairs)
+    {
+        Dictionary<int, Record> results = new();
+        List<bool> nests = new();
+        WorkItem? parentWorkItem;
+        ReadOnlyCollection<Record> records;
+        foreach (KeyValuePair<int, WorkItem> keyValuePair in keyValuePairs)
+        {
+            nests.Clear();
+            if (keyValuePair.Value.Parent is null)
+                parentWorkItem = null;
+            else
+                _ = keyValuePairs.TryGetValue(keyValuePair.Value.Parent.Value, out parentWorkItem);
+            try
+            {
+                records = GetKeyValuePairs(keyValuePairs, keyValuePair.Value, nests);
+                results.Add(keyValuePair.Key, new(keyValuePair.Value, parentWorkItem, records));
+            }
+            catch (Exception)
+            {
+                results.Add(keyValuePair.Key, new(keyValuePair.Value, parentWorkItem, new(Array.Empty<Record>())));
+            }
+        }
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<string> GetDirectories(string destinationDirectory, ReadOnlyDictionary<int, Record> keyValuePairs)
+    {
+        List<string> results = new();
+        Record record;
+        string directory;
+        List<bool> nests = new();
+        ReadOnlyCollection<string> childrenDirectories;
+        string dateDirectory = Path.Combine(destinationDirectory, "_", DateTime.Now.ToString("yyyy-MM-dd"));
+        foreach (KeyValuePair<int, Record> keyValuePair in keyValuePairs)
+        {
+            record = keyValuePair.Value;
+            if (record.Parent is not null && (record.WorkItem.Parent is null || record.Parent.Id != record.WorkItem.Parent.Value))
+                continue;
+            if (record.Parent is not null)
+                continue;
+            // if (record.WorkItem.Id == 110730)
+            //     continue;
+            // if (record.WorkItem.Id == 110732)
+            //     continue;
+            nests.Clear();
+            directory = Path.Combine(dateDirectory, $"{record.WorkItem.WorkItemType.Substring(0, 1)}-{record.WorkItem.Id}-{record.WorkItem.Title.Trim().Substring(0, 1)}");
+            childrenDirectories = GetChildrenDirectories(keyValuePairs, nests, directory, record);
+            results.AddRange(childrenDirectories);
+        }
+        return new(results.Distinct().ToArray());
+    }
+
+    private static string GetLine(List<char> spaces, WorkItem workItem, Record record, bool condensed, bool sprintOnly)
+    {
+        string result;
+        string closed = GetClosed(workItem);
+        result = sprintOnly ? $"\t- [ ] {workItem.IterationPath}" :
+            condensed ? $"{new string(spaces.Skip(1).ToArray())}- {closed} {record.WorkItem.Id} - {workItem.Title}" :
+            $"{new string(spaces.Skip(1).ToArray())}- {closed} {record.WorkItem.Id} - {workItem.Title} ~~~ {workItem.AssignedTo} - {workItem.IterationPath.Replace('\\', '-')} - {workItem.CreatedDate} --- {workItem.ClosedDate}";
+        return result;
+    }
+
+    private static ReadOnlyCollection<Record> GetKeyValuePairs(ReadOnlyDictionary<int, WorkItem> keyValuePairs, WorkItem workItem, List<bool> nests)
+    {
+        List<Record> results = new();
+        int? childId;
+        nests.Add(true);
+        WorkItem? childWorkItem;
+        WorkItem? parentWorkItem;
+        List<WorkItem> collection = new();
+        ReadOnlyCollection<Record> records;
+        if (workItem.Relations is not null && workItem.Relations.Length > 0)
+        {
+            collection.Clear();
+            foreach (Relation relation in workItem.Relations)
+            {
+                childId = GetIdFromUrlIfChild(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);
+                records = GetKeyValuePairs(keyValuePairs, w, nests);
+                results.Add(new(w, parentWorkItem, records));
+            }
+        }
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<string> GetChildrenDirectories(ReadOnlyDictionary<int, Record> keyValuePairs, List<bool> nests, string parentDirectory, Record record)
+    {
+        List<string> results = new();
+        nests.Add(true);
+        string directory;
+        Record? childRecord;
+        ReadOnlyCollection<string> childrenDirectories;
+        foreach (Record r in record.Children)
+        {
+            // if (record.WorkItem.Id == 110730)
+            //     continue;
+            // if (record.WorkItem.Id == 110732)
+            //     continue;
+            directory = Path.Combine(parentDirectory, $"{r.WorkItem.WorkItemType.Substring(0, 1)}-{r.WorkItem.Id}-{r.WorkItem.Title.Trim().Substring(0, 1)}");
+            results.Add(directory);
+            if (!keyValuePairs.TryGetValue(r.WorkItem.Id, out childRecord))
+                continue;
+            if (nests.Count > 99)
+                break;
+            childrenDirectories = GetChildrenDirectories(keyValuePairs, nests, directory, childRecord);
+            results.AddRange(childrenDirectories);
+        }
+        return new(results);
+    }
+
+    private static string GetClosed(WorkItem workItem) =>
+        workItem.State != "Closed" ? "[ ]" : "[x]";
+
+    private static int? GetIdFromUrlIfChild(Relation relation)
+    {
+        int? result;
+        string[] segments = relation?.Attributes is null || relation.Attributes.Name != "Child" ? 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;
+    }
+
+    private static void FilterChildren(ReadOnlyCollection<string> workItemTypes, Record record, List<WorkItem> results)
+    {
+        foreach (Record r in record.Children)
+        {
+            if (!workItemTypes.Contains(r.WorkItem.WorkItemType))
+                continue;
+            results.Add(r.WorkItem);
+            FilterChildren(workItemTypes, r, results);
+        }
+    }
+
+    private static ReadOnlyCollection<WorkItem> FilterChildren(ReadOnlyCollection<string> workItemTypes, Record record)
+    {
+        List<WorkItem> results = new();
+        FilterChildren(workItemTypes, record, results);
+        return new(results);
+    }
+
+    private static int GetState(WorkItem workItem) =>
+        workItem.State switch
+        {
+            "New" => 1,
+            "Active" => 2,
+            "Resolved" => 3,
+            "Closed" => 4,
+            "Removed" => 5,
+            _ => 8
+        };
+
+    private static string? GetMaxIterationPath122508(ReadOnlyCollection<WorkItem> workItems)
+    {
+        string? result;
+        List<string> results = new();
+        foreach (WorkItem workItem in workItems)
+        {
+            if (results.Contains(workItem.IterationPath))
+                continue;
+            results.Add(workItem.IterationPath);
+        }
+        result = results.Count == 0 ? null : results.Max();
+        return result;
+    }
+
+    private static ReadOnlyCollection<WorkItem> FeatureCheckIterationPath122508(string url, List<string> lines, ReadOnlyCollection<string> workItemTypes, ReadOnlyCollection<Record> records, string workItemType)
+    {
+        List<WorkItem> results = new();
+        string? maxIterationPath;
+        List<string> collection = new();
+        ReadOnlyCollection<WorkItem> childrenWorkItems;
+        foreach (Record record in records)
+        {
+            if (record.WorkItem.State is "Removed")
+                continue;
+            if (record.WorkItem.WorkItemType != workItemType)
+                continue;
+            collection.Clear();
+            if (record.Children.Count == 0)
+                continue;
+            childrenWorkItems = FilterChildren(workItemTypes, record);
+            maxIterationPath = GetMaxIterationPath122508(childrenWorkItems);
+            if (string.IsNullOrEmpty(maxIterationPath) || record.WorkItem.IterationPath == maxIterationPath)
+                continue;
+            collection.Add($"## {record.WorkItem.AssignedTo} - {record.WorkItem.Id} - {record.WorkItem.Title}");
+            collection.Add(string.Empty);
+            collection.Add($"- [ ] [{record.WorkItem.Id}]({url}{record.WorkItem.Id}) => {record.WorkItem.IterationPath} != {maxIterationPath}");
+            collection.Add(string.Empty);
+            lines.AddRange(collection);
+            results.Add(WorkItem.Get(record.WorkItem, $"IterationPath:<a target='_blank' href='{url}{record.WorkItem.Id}'>{record.WorkItem.Id}</a>;{record.WorkItem.IterationPath} != {maxIterationPath}"));
+        }
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<WorkItem> GetWorkItemsNotMatching122514(Record record, ReadOnlyCollection<WorkItem> workItems)
+    {
+        List<WorkItem> results = new();
+        string[] segments;
+        string[] parentTags = record.WorkItem.Tags.Split(';').Select(l => l.Trim()).ToArray();
+        foreach (WorkItem workItem in workItems)
+        {
+            segments = string.IsNullOrEmpty(workItem.Tags) ? Array.Empty<string>() : workItem.Tags.Split(';').Select(l => l.Trim()).ToArray();
+            if (segments.Length > 0 && parentTags.Any(l => segments.Contains(l)))
+                continue;
+            results.Add(workItem);
+        }
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<WorkItem> FeatureCheckTag122514(string url, List<string> lines, ReadOnlyCollection<string> workItemTypes, ReadOnlyCollection<Record> records, string workItemType)
+    {
+        List<WorkItem> results = new();
+        List<string> collection = new();
+        List<string> violations = new();
+        ReadOnlyCollection<WorkItem> childrenWorkItems;
+        ReadOnlyCollection<WorkItem> workItemsNotMatching;
+        foreach (Record record in records)
+        {
+            if (record.WorkItem.State is "Removed")
+                continue;
+            if (record.WorkItem.WorkItemType != workItemType)
+                continue;
+            collection.Clear();
+            violations.Clear();
+            if (record.Children.Count == 0)
+                continue;
+            if (string.IsNullOrEmpty(record.WorkItem.Tags))
+                workItemsNotMatching = new(new WorkItem[] { record.WorkItem });
+            else
+            {
+                childrenWorkItems = FilterChildren(workItemTypes, record);
+                workItemsNotMatching = GetWorkItemsNotMatching122514(record, childrenWorkItems);
+                if (!string.IsNullOrEmpty(record.WorkItem.Tags) && workItemsNotMatching.Count == 0)
+                    continue;
+            }
+            collection.Add($"## {record.WorkItem.AssignedTo} - {record.WorkItem.Id} - {record.WorkItem.Title}");
+            collection.Add(string.Empty);
+            foreach (WorkItem workItem in workItemsNotMatching)
+                collection.Add($"- [ ] [{workItem}]({url}{workItem}) {nameof(record.WorkItem.Tags)} != {record.WorkItem.Tags}");
+            collection.Add(string.Empty);
+            lines.AddRange(collection);
+            violations.Add($"Tag:{record.WorkItem.Tags};");
+            foreach (WorkItem workItem in workItemsNotMatching)
+                violations.Add($"<a target='_blank' href='{url}{workItem.Id}'>{workItem.Id}</a>:{workItem.Tags};");
+            results.Add(WorkItem.Get(record.WorkItem, string.Join(" ", violations)));
+        }
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<WorkItem> GetWorkItemsNotMatching126169(Record record, ReadOnlyCollection<WorkItem> workItems)
+    {
+        List<WorkItem> results = new();
+        foreach (WorkItem workItem in workItems)
+        {
+            if (record.WorkItem.Priority is null)
+            {
+                results.Add(record.WorkItem);
+                break;
+            }
+            if (workItem.Priority == record.WorkItem.Priority.Value)
+                continue;
+            results.Add(workItem);
+        }
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<WorkItem> FeatureCheckPriority126169(string url, List<string> lines, ReadOnlyCollection<string> workItemTypes, ReadOnlyCollection<Record> records, string workItemType)
+    {
+        List<WorkItem> results = new();
+        List<string> collection = new();
+        List<string> violations = new();
+        ReadOnlyCollection<WorkItem> childrenWorkItems;
+        ReadOnlyCollection<WorkItem> workItemsNotMatching;
+        foreach (Record record in records)
+        {
+            if (record.WorkItem.State is "Removed")
+                continue;
+            if (record.WorkItem.WorkItemType != workItemType)
+                continue;
+            collection.Clear();
+            violations.Clear();
+            if (record.Children.Count == 0)
+                continue;
+            childrenWorkItems = FilterChildren(workItemTypes, record);
+            workItemsNotMatching = GetWorkItemsNotMatching126169(record, childrenWorkItems);
+            if (workItemsNotMatching.Count == 0)
+                continue;
+            collection.Add($"## {record.WorkItem.AssignedTo} - {record.WorkItem.Id} - {record.WorkItem.Title}");
+            collection.Add(string.Empty);
+            collection.Add($"- [{record.WorkItem.Id}]({url}{record.WorkItem.Id})");
+            foreach (WorkItem workItem in workItemsNotMatching)
+                collection.Add($"- [ ] [{workItem.Id}]({url}{workItem.Id}) {nameof(record.WorkItem.Priority)} != {record.WorkItem.Priority}");
+            collection.Add(string.Empty);
+            lines.AddRange(collection);
+            violations.Add($"Priority:{record.WorkItem.Priority};");
+            foreach (WorkItem workItem in workItemsNotMatching)
+                violations.Add($"<a target='_blank' href='{url}{workItem.Id}'>{workItem.Id}</a>:{workItem.Priority};");
+            results.Add(WorkItem.Get(record.WorkItem, string.Join(" ", violations)));
+        }
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<WorkItem> GetWorkItemsNotMatching123066(Record record, ReadOnlyCollection<WorkItem> workItems)
+    {
+        List<WorkItem> results = new();
+        int check;
+        int state = GetState(record.WorkItem);
+        List<KeyValuePair<int, WorkItem>> collection = new();
+        foreach (WorkItem workItem in workItems)
+        {
+            if (workItem.State is "Removed")
+                continue;
+            check = GetState(workItem);
+            if (check == state)
+                continue;
+            collection.Add(new(check, workItem));
+        }
+        if (collection.Count > 0)
+        {
+            KeyValuePair<int, WorkItem>[] notNewState = (from l in collection where l.Value.State != "New" select l).ToArray();
+            if (notNewState.Length == 0 && record.WorkItem.State is "New" or "Active")
+                collection.Clear();
+            else if (notNewState.Length > 0)
+            {
+                int minimum = notNewState.Min(l => l.Key);
+                if (minimum == state)
+                    collection.Clear();
+                else if (minimum == 1 && record.WorkItem.State == "New")
+                    collection.Clear();
+                else if (notNewState.Length > 0 && record.WorkItem.State == "Active")
+                    collection.Clear();
+            }
+        }
+        foreach (KeyValuePair<int, WorkItem> keyValuePair in collection.OrderByDescending(l => l.Key))
+            results.Add(keyValuePair.Value);
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<WorkItem> GetWorkItemsNotMatching123067(Record record, ReadOnlyCollection<WorkItem> workItems)
+    {
+        List<WorkItem> results = new();
+        int check;
+        int state = GetState(record.WorkItem);
+        List<KeyValuePair<int, WorkItem>> collection = new();
+        foreach (WorkItem workItem in workItems)
+        {
+            if (workItem.State is "Removed")
+                continue;
+            check = GetState(workItem);
+            if (check == state)
+                continue;
+            collection.Add(new(check, workItem));
+        }
+        if (collection.Count > 0)
+        {
+            KeyValuePair<int, WorkItem>[] notNewState = (from l in collection where l.Value.State != "New" select l).ToArray();
+            if (notNewState.Length == 0 && record.WorkItem.State is "New" or "Active")
+                collection.Clear();
+            else if (notNewState.Length > 0)
+            {
+                int minimum = notNewState.Min(l => l.Key);
+                if (minimum == state)
+                    collection.Clear();
+                else if (minimum == 1 && record.WorkItem.State == "New")
+                    collection.Clear();
+                else if (notNewState.Length > 0 && record.WorkItem.State == "Active")
+                    collection.Clear();
+            }
+        }
+        foreach (KeyValuePair<int, WorkItem> keyValuePair in collection.OrderByDescending(l => l.Key))
+            results.Add(keyValuePair.Value);
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<WorkItem> FeatureCheckState123066(string url, List<string> lines, ReadOnlyCollection<string> workItemTypes, ReadOnlyCollection<Record> records, string workItemType)
+    {
+        List<WorkItem> results = new();
+        List<string> collection = new();
+        List<string> violations = new();
+        ReadOnlyCollection<WorkItem> childrenWorkItems;
+        ReadOnlyCollection<WorkItem> workItemsNotMatching;
+        foreach (Record record in records)
+        {
+            if (record.WorkItem.State is "Removed")
+                continue;
+            if (record.WorkItem.WorkItemType != workItemType)
+                continue;
+            collection.Clear();
+            violations.Clear();
+            if (record.Children.Count == 0)
+                continue;
+            childrenWorkItems = FilterChildren(workItemTypes, record);
+            workItemsNotMatching = GetWorkItemsNotMatching123066(record, childrenWorkItems);
+            if (workItemsNotMatching.Count == 0)
+                continue;
+            collection.Add($"## {record.WorkItem.AssignedTo} - {record.WorkItem.Id} - {record.WorkItem.Title}");
+            collection.Add(string.Empty);
+            collection.Add($"- [{record.WorkItem.Id}]({url}{record.WorkItem.Id})");
+            foreach (WorkItem workItem in workItemsNotMatching)
+                collection.Add($"- [ ] [{workItem.Id}]({url}{workItem.Id}) {nameof(record.WorkItem.State)} != {record.WorkItem.State}");
+            collection.Add(string.Empty);
+            lines.AddRange(collection);
+            violations.Add($"State:{record.WorkItem.State};");
+            foreach (WorkItem workItem in workItemsNotMatching)
+                violations.Add($"<a target='_blank' href='{url}{workItem.Id}'>{workItem.Id}</a>:{workItem.State};");
+            results.Add(WorkItem.Get(record.WorkItem, string.Join(" ", violations)));
+        }
+        return new(results);
+    }
+
+    private static ReadOnlyCollection<WorkItem> FeatureCheckState123067(string url, List<string> lines, ReadOnlyCollection<string> workItemTypes, ReadOnlyCollection<Record> records, string workItemType)
+    {
+        List<WorkItem> results = new();
+        List<string> collection = new();
+        List<string> violations = new();
+        ReadOnlyCollection<WorkItem> childrenWorkItems;
+        ReadOnlyCollection<WorkItem> workItemsNotMatching;
+        foreach (Record record in records)
+        {
+            if (record.WorkItem.State is "Removed")
+                continue;
+            if (record.WorkItem.WorkItemType != workItemType)
+                continue;
+            collection.Clear();
+            violations.Clear();
+            if (record.Children.Count == 0)
+                continue;
+            childrenWorkItems = FilterChildren(workItemTypes, record);
+            workItemsNotMatching = GetWorkItemsNotMatching123067(record, childrenWorkItems);
+            if (workItemsNotMatching.Count == 0)
+                continue;
+            collection.Add($"## {record.WorkItem.AssignedTo} - {record.WorkItem.Id} - {record.WorkItem.Title}");
+            collection.Add(string.Empty);
+            collection.Add($"- [{record.WorkItem.Id}]({url}{record.WorkItem.Id})");
+            foreach (WorkItem workItem in workItemsNotMatching)
+                collection.Add($"- [ ] [{workItem.Id}]({url}{workItem.Id}) {nameof(record.WorkItem.State)} != {record.WorkItem.State}");
+            collection.Add(string.Empty);
+            lines.AddRange(collection);
+            violations.Add($"State:{record.WorkItem.State};");
+            foreach (WorkItem workItem in workItemsNotMatching)
+                violations.Add($"<a target='_blank' href='{url}{workItem.Id}'>{workItem.Id}</a>:{workItem.State};");
+            results.Add(WorkItem.Get(record.WorkItem, string.Join(" ", violations)));
+        }
+        return new(results);
+    }
+
+}