Auto stash before merge of "main" and "origin/main"

Core/Configurations/ConfigurationBuilder.cs

@@ -1,61 +1,116 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
+using Newtonsoft.Json.Linq;
 namespace Core.Configurations
 {
-	public class ConfigurationBuilder
-	{
-		private readonly List<IConfigurationProvider> _providers = new();
+    public interface IConfigurationBuilder
+    {
+        ConfigurationBuilder AddProvider(IConfigurationProvider provider);
+        IConfigurationRoot Build();
+        List<IConfigurationProvider> ConfigurationProviders { get; }
+    }
 
-		public ConfigurationBuilder AddProvider(IConfigurationProvider provider)
-		{
-			_providers.Add(provider);
-			return this;
-		}
+    public class ConfigurationBuilder : IConfigurationBuilder
+    {
+        public List<IConfigurationProvider> ConfigurationProviders { get; private set; } = [];
 
-		public IConfigurationRoot Build()
-		{
-			// Her kan du implementere din egen sammenlægningslogik
-			return new ConfigurationRoot(_providers);
-		}
-	}
+        public ConfigurationBuilder AddProvider(IConfigurationProvider provider)
+        {
+            ((IConfigurationBuilder)this).ConfigurationProviders.Add(provider);
+            return this;
+        }
+        public IConfigurationRoot Build()
+        {
+            foreach (var provider in ConfigurationProviders)
+            {
+                provider.Build();
+            }
+            //TODO: we need to come up with merge strategy
 
-	public class ConfigurationRoot : IConfigurationRoot
-	{
-		public ConfigurationRoot(List<IConfigurationProvider> configurationProviders)
-		{
+            return new ConfigurationRoot(ConfigurationProviders);
+        }
+    }
 
-		}
-		public T GetSection<T>(string key)
-		{
-			throw new NotImplementedException();
-		}
-	}
-	public static class ConfigurationPredicateExtensions
-	{
+    public class ConfigurationRoot : IConfigurationRoot
+    {
+        List<IConfigurationProvider> IConfigurationRoot.ConfigurationProviders { get; set; }
 
-		public static IConfigurationSection GetSection(this IConfigurationRoot configurationSection, string key)
-		{
-			return null;
-		}
+        public ConfigurationRoot(List<IConfigurationProvider> configurationProviders)
+        {
+            ((IConfigurationRoot)this).ConfigurationProviders = configurationProviders;
+        }
 
-		public static T Get<T>(this IConfigurationSection configuration, string key)
-		{
-			return default(T);
-		}
-	}
-	public interface IConfigurationProvider
-	{
-		Dictionary<string, object> Configuration();
-	}
+    }
+    public static class ConfigurationBinder
+    {
+        private static string NormalizePath(string path)
+        {
+            return path?.Replace(":", ".", StringComparison.Ordinal) ?? string.Empty;
+        }
+        public static string GetConnectionString(this IConfigurationRoot configuration, string name)
+        {
+            return configuration.GetSection("ConnectionStrings").Get<string>(name);
+        }
+        public static IConfigurationSection GetSection(this IConfigurationRoot configuration, string path)
+        {
+            JToken value = null;
+            foreach (var provider in configuration.ConfigurationProviders)
+            {
+                var test = provider.Configuration().SelectToken(NormalizePath(path));
 
-	public interface IConfigurationSection
-	{
-		string Key { get; }
-		string Path { get; }
-		string Value { get; set; }
-	}
+                if (test != null)
+                    value = test;
+            }
+
+            return new ConfigurationSection { Path = path, Key = path.Split(':').Last(), Value = value };
+        }
+        public static T Get<T>(this IConfigurationRoot configuration, string path)
+        {
+            JToken value = null;
+            foreach (var provider in configuration.ConfigurationProviders)
+            {
+                var test = provider.Configuration().SelectToken(NormalizePath(path));
+
+                if (test != null)
+                    value = test;
+            }
+
+            return value.ToObject<T>();
+        }
+        public static T Get<T>(this IConfigurationSection configuration, string path)
+        {
+            var value = configuration.Value.SelectToken(NormalizePath(path)).ToObject<T>();
+            return value;
+        }
+        public static T ToObject<T>(this IConfigurationSection configuration)
+        {
+            var value = configuration.Value.ToObject<T>();
+            return value;
+        }
+
+        [Obsolete("Use ToObject")]
+        public static T Get<T>(this IConfigurationSection configuration)
+        {
+            return configuration.Value.ToObject<T>();
+        }
+
+    }
+    public interface IConfigurationProvider
+    {
+        void Build();
+        Newtonsoft.Json.Linq.JObject Configuration();
+    }
+
+    public class ConfigurationSection : IConfigurationSection
+    {
+        public required string Path { get; set; }
+        public required string Key { get; set; }
+
+        public required JToken Value { get; set; }
+
+    }
+    public interface IConfigurationSection
+    {
+        string Path { get; }
+        string Key { get; }
+        Newtonsoft.Json.Linq.JToken Value { get; set; }
+    }
 }