rework to Azaion.Suite

Azaion.Common/Extensions/ColorExtensions.cs

@@ -0,0 +1,28 @@
+using System.Windows.Media;
+
+namespace Azaion.Common.Extensions;
+
+public static class ColorExtensions
+{
+    public static Color ToColor(this int id)
+    {
+        var index = id % ColorValues.Length;
+        var hex = index == -1
+            ? "#40DDDDDD"
+            : $"#40{ColorValues[index]}";
+        var color =(Color)ColorConverter.ConvertFromString(hex);
+        return color;
+    }
+    
+    private static readonly string[] ColorValues =
+    [
+        "FF0000", "00FF00", "0000FF", "FFFF00", "FF00FF", "00FFFF", "000000",
+        "800000", "008000", "000080", "808000", "800080", "008080", "808080", 
+        "C00000", "00C000", "0000C0", "C0C000", "C000C0", "00C0C0", "C0C0C0", 
+        "400000", "004000", "000040", "404000", "400040", "004040", "404040", 
+        "200000", "002000", "000020", "202000", "200020", "002020", "202020", 
+        "600000", "006000", "000060", "606000", "600060", "006060", "606060", 
+        "A00000", "00A000", "0000A0", "A0A000", "A000A0", "00A0A0", "A0A0A0", 
+        "E00000", "00E000", "0000E0", "E0E000", "E000E0", "00E0E0", "E0E0E0"
+    ];
+}

Azaion.Common/Extensions/DenseDateTimeConverter.cs

@@ -0,0 +1,12 @@
+using Newtonsoft.Json.Converters;
+
+namespace Azaion.Common.Extensions;
+
+public class DenseDateTimeConverter : IsoDateTimeConverter
+{
+    public DenseDateTimeConverter()
+    {
+        DateTimeFormat = "yy-MM-dd HH:mm:ss";
+    }
+    
+}

Azaion.Common/Extensions/DirectoryInfoExtensions.cs

@@ -0,0 +1,10 @@
+using System.IO;
+
+namespace Azaion.Annotator.Extensions;
+
+public static class DirectoryInfoExtensions
+{
+    public static IEnumerable<FileInfo> GetFiles(this DirectoryInfo dir, params string[] searchExtensions) =>
+        dir.GetFiles("*.*", SearchOption.AllDirectories)
+            .Where(f => searchExtensions.Any(s => f.Name.Contains(s, StringComparison.CurrentCultureIgnoreCase))).ToList();
+}

Azaion.Common/Extensions/ParallelExt.cs

@@ -0,0 +1,67 @@
+namespace Azaion.Annotator.Extensions;
+
+public class ParallelOptions
+{
+    public int ProgressUpdateInterval { get; set; } = 100;
+    public Func<int, Task> ProgressFn { get; set; } = null!;
+    public double CpuUtilPercent { get; set; } = 100;
+}
+
+public class ParallelExt
+{
+    public static async Task ForEachAsync<T>(ICollection<T> source,
+        Func<T, CancellationToken, ValueTask> processFn,
+        ParallelOptions? parallelOptions = null,
+        CancellationToken cancellationToken = default)
+    {
+        parallelOptions ??= new ParallelOptions
+        {
+            CpuUtilPercent = 100,
+            ProgressUpdateInterval = 100,
+            ProgressFn = i =>
+            {
+                Console.WriteLine($"Processed {i} item by Task {Task.CurrentId}%");
+                return Task.CompletedTask;
+            }
+        };
+        var threadsCount = (int)(Environment.ProcessorCount * parallelOptions.CpuUtilPercent / 100.0);
+
+        var processedCount = 0;
+        var chunkSize = Math.Max(1, (int)(source.Count / (decimal)threadsCount));
+        var chunks = source.Chunk(chunkSize).ToList();
+        if (chunks.Count > threadsCount)
+        {
+            chunks[^2] = chunks[^2].Concat(chunks.Last()).ToArray();
+            chunks.RemoveAt(chunks.Count - 1);
+        }
+        var progressUpdateLock = new SemaphoreSlim(1);
+
+        var tasks = new List<Task>();
+        foreach (var chunk in chunks)
+        {
+            tasks.Add(await Task.Factory.StartNew(async () =>
+            {
+                foreach (var item in chunk)
+                {
+                    await processFn(item, cancellationToken);
+                    Interlocked.Increment(ref processedCount);
+                    if (processedCount % parallelOptions.ProgressUpdateInterval == 0 && parallelOptions.ProgressFn != null)
+                        _ = Task.Run(async () =>
+                        {
+                            await progressUpdateLock.WaitAsync(cancellationToken);
+                            try
+                            {
+                                await parallelOptions.ProgressFn(processedCount);
+                            }
+                            finally
+                            {
+                                progressUpdateLock.Release();
+                            }
+                        }, cancellationToken);
+                }
+
+            }, TaskCreationOptions.LongRunning));
+        }
+        await Task.WhenAll(tasks);
+    }
+}

Azaion.Common/Extensions/ThrottleExtensions.cs

@@ -0,0 +1,19 @@
+namespace Azaion.Annotator.Extensions;
+
+public static class ThrottleExt
+{
+    private static bool _throttleOn;
+    public static async Task Throttle(Func<Task> func, TimeSpan? throttleTime = null)
+    {
+        if (_throttleOn)
+            return;
+
+        _throttleOn = true;
+        await func();
+        _ = Task.Run(async () =>
+        {
+            await Task.Delay(throttleTime ?? TimeSpan.FromMilliseconds(500));
+            _throttleOn = false;
+        });
+    }
+}

Azaion.Common/Extensions/WindowExtensions.cs

@@ -0,0 +1,20 @@
+using System.Windows;
+using Azaion.Common.DTO;
+
+namespace Azaion.Common.Extensions;
+
+public static class WindowExtensions
+{
+    public static WindowEnum GetParentWindow(this FrameworkElement? element)
+    {
+        while (element != null && element is not Window)
+        {
+            element = element.Parent as FrameworkElement;
+        }
+
+        if (element is not Window)
+            return WindowEnum.None;
+
+        return WindowEnum.Annotator;
+    }
+}