Mongodb dotnet10

.dockerignore

@@ -332,3 +332,6 @@
 
 # performance testing sandbox
 **/sandbox
+
+# Vite
+# **/build/ huh, also ignored when building inside dockerfile, thought it was only during COPY... 

Common.Web/Common.Web.csproj

@@ -1,6 +1,6 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
@@ -9,8 +9,7 @@
     <PackageReference Include="Microsoft.ApplicationInsights" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" />
-    <PackageReference Include="System.IdentityModel.Tokens.Jwt" VersionOverride="8.0.1" />
-    <PackageReference Include="System.Text.Encodings.Web" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" VersionOverride="8.18.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\PluginModuleBase\PluginModuleBase.csproj" />

Common.Web/Extensions.cs

@@ -0,0 +1,16 @@
+using Microsoft.Extensions.Hosting;
+
+namespace Common.Web
+{
+	public static class Extensions
+	{
+		public static bool HasEnvironmentPart(this IHostEnvironment hostEnvironment, string environmentPart)
+		{
+			ArgumentNullException.ThrowIfNull(hostEnvironment);
+			return hostEnvironment.EnvironmentName.Split('.')
+				.Any(part => string.Equals(environmentPart, part, StringComparison.OrdinalIgnoreCase));
+		}
+		public static bool HasDevelopmentEnvironment(this IHostEnvironment hostEnvironment)
+			=> hostEnvironment.HasEnvironmentPart(Environments.Development);
+	}
+}

Common.Web/ServiceConfiguration.cs

@@ -10,15 +10,15 @@ namespace Common.Web
 {
     public static class ServiceConfiguration
     {
-        public static void ConfigureProcessingPipelineServices(IServiceCollection services, IEnumerable<IPluginModule> pluginModules)
+        public static void ConfigureProcessingPipelineServices(IServiceCollection services, IConfiguration config, IEnumerable<IPluginModule> pluginModules)
         {
             services.AddSingleton<ITableClientFactory, TableClientFactory>(); //(sp => new TableClientFactory("vektor")
-            services.AddSingleton<IDataSink, AzureTableLogSink>();
+            services.AddSingleton<IDataSink, NullDataSink>();
             services.AddSingleton<IProcessingMiddlewarePipelineRepository, ProcessingPipelineRepository>();
             services.AddSingleton<SinkProcessingMiddleware>();
 
             foreach (var plugin in pluginModules)
-                plugin.ConfigureServices(services);
+                plugin.ConfigureServices(services, config);
         }
 
         public static void ConfigurePlugins(IApplicationBuilder app, IEnumerable<IPluginModule> pluginModules)
@@ -36,7 +36,8 @@ public static void ConfigureApplicationInsights(IApplicationBuilder app, IConfig
             if (aiConn == "SECRET" || aiConn == string.Empty)
             {
                 if (isDevelopment == false)
-                    throw new ArgumentException("InstrumentationKey not set");
+                    Console.WriteLine($"Warning: InstrumentationKey not set ({aiConn})");
+                    //throw new ArgumentException("InstrumentationKey not set");
             }
             else
             {

Common.Web/TypedConfiguration.cs

@@ -21,55 +21,101 @@ public class TypedConfiguration
             // https://referbruv.com/blog/posts/working-with-options-pattern-in-aspnet-core-the-complete-guide
             var appSettings = new T();
 
-            config.GetSection(sectionKey).Bind(appSettings);
-            services.AddSingleton(appSettings.GetType(), appSettings!);
+            //config.GetSection(sectionKey).Bind(appSettings);
+            //services.AddSingleton(appSettings.GetType(), appSettings!);
 
-            RecurseBind(appSettings, services, config);
+            //RecurseBind(appSettings, services, config);
+			XBind(appSettings, services, config.GetSection(typeof(T).Name));
+			// https://kaylumah.nl/2021/11/29/validated-strongly-typed-ioptions.html
+			// If we want to inject IOptions<Type> instead of just Type, this is needed: https://stackoverflow.com/a/61157181 services.ConfigureOptions(instance)
+			//services.Configure<AceKnowledgeOptions>(config.GetSection("AceKnowledge"));
 
-            // https://kaylumah.nl/2021/11/29/validated-strongly-typed-ioptions.html
-            // If we want to inject IOptions<Type> instead of just Type, this is needed: https://stackoverflow.com/a/61157181 services.ConfigureOptions(instance)
-            //services.Configure<AceKnowledgeOptions>(config.GetSection("AceKnowledge"));
-
-            return appSettings;
+			return appSettings;
         }
 
-        private static void RecurseBind(object appSettings, IServiceCollection services, IConfiguration config)
+		private static void XBind(object setting, IServiceCollection services, IConfiguration config)
+		{
+			config.Bind(setting);
+			Rec(setting);
+			void Rec(object s)
+			{
+				services.AddSingleton(s.GetType(), s);
+				var props = s.GetType()
+								.GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
+				foreach (var item in props)
+				{
+					if (item.PropertyType == typeof(string) || item.PropertyType.IsPrimitive)
+					{ }
+					else if (item.PropertyType.IsAssignableTo(typeof(System.Collections.IEnumerable))
+						&& item.PropertyType.IsGenericType)
+					{ }
+					else
+					{
+						var v = item.GetValue(s);
+						if (v != null)
+							Rec(v);
+					}
+				}
+			}
+		}
+
+		private static void RecurseBind(object appSettings, IServiceCollection services, IConfiguration config)
         {
-            var props = appSettings.GetType()
-                .GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public)
-                .Where(o => !o.PropertyType.IsSealed); // TODO: (low) better check than IsSealed (also unit test)
+			var props = appSettings.GetType()
+							.GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public)
+							; //.Where(o => !o.PropertyType.IsSealed); // TODO: (low) better check than IsSealed (also unit test)
 
-            foreach (var prop in props)
-            {
-                var instance = prop.GetValue(appSettings);
-                //config.GetSection(prop.Name).Bind(instance);
-                services.AddSingleton(instance!.GetType(), instance!);
+			foreach (var prop in props)
+			{
+				var instance = prop.GetValue(appSettings);
+				if (instance == null)
+				{
+					var isNullable = Nullable.GetUnderlyingType(prop.PropertyType) != null;
+					if (isNullable)
+						continue;
+					if (prop.GetCustomAttributes(typeof(System.Runtime.CompilerServices.NullableAttribute), true).Any())
+						continue;
+					throw new Exception($"Null value for non-nullable property '{prop.Name}'");
+				}
+				//config.GetSection(prop.Name).Bind(instance);
 
-                RecurseBind(instance, services, config);
+				if (instance is System.Collections.IList lst)
+				{
+					foreach (var item in lst)
+					{
+						services.AddSingleton(item.GetType(), item);
+						//RecurseBind(item, services, config);
+					}
+				}
+				else
+				{
+					services.AddSingleton(instance!.GetType(), instance!);
+					RecurseBind(instance, services, config);
+				}
 
-                //var asOptions = Microsoft.Extensions.Options.Options.Create(instance);
-                //services.ConfigureOptions(instance);
+				//var asOptions = Microsoft.Extensions.Options.Options.Create(instance);
+				//services.ConfigureOptions(instance);
 
-                // Execute validation (if available)
-                var validatorType = instance.GetType().Assembly.GetTypes()
-                   .Where(t =>
-                   {
-                       var validatorInterface = t.GetInterfaces().SingleOrDefault(o =>
-                       o.IsGenericType && o.GetGenericTypeDefinition() == typeof(Microsoft.Extensions.Options.IValidateOptions<>));
-                       return validatorInterface != null && validatorInterface.GenericTypeArguments.Single() == instance.GetType();
-                   }
-                   ).FirstOrDefault();
-                if (validatorType != null)
-                {
-                    var validator = Activator.CreateInstance(validatorType);
-                    var m = validatorType.GetMethod("Validate");
-                    var result = (Microsoft.Extensions.Options.ValidateOptionsResult?)m?.Invoke(validator, new object[] { "", instance });
-                    if (result!.Failed)
-                    {
-                        throw new Exception($"{validatorType.Name}: {result.FailureMessage}");
-                    }
-                }
-            }
-        }
+				// Execute validation (if available)
+				var validatorType = instance.GetType().Assembly.GetTypes()
+					   .Where(t =>
+					   {
+						   var validatorInterface = t.GetInterfaces().SingleOrDefault(o =>
+						   o.IsGenericType && o.GetGenericTypeDefinition() == typeof(Microsoft.Extensions.Options.IValidateOptions<>));
+						   return validatorInterface != null && validatorInterface.GenericTypeArguments.Single() == instance.GetType();
+					   }
+					   ).FirstOrDefault();
+				if (validatorType != null)
+				{
+					var validator = Activator.CreateInstance(validatorType);
+					var m = validatorType.GetMethod("Validate");
+					var result = (Microsoft.Extensions.Options.ValidateOptionsResult?)m?.Invoke(validator, new object[] { "", instance });
+					if (result!.Failed)
+					{
+						throw new Exception($"{validatorType.Name}: {result.FailureMessage}");
+					}
+				}
+			}
+		}
     }
 }

Common/Class1.cs

@@ -2,6 +2,69 @@
 
 namespace Common.LLM
 {
+	public interface ILlmServiceFactory
+	{
+		ILlmService? Get(string? preferredModelName = null, string? preferredService = null);
+
+		public ILlmService GetOrDefault(ILlmService defaultValue, string? preferredModelName = null, string? preferredService = null)
+			=> Get(preferredModelName, preferredService) ?? defaultValue;
+
+		public ILlmService GetOrThrow(string? preferredModelName = null, string? preferredService = null)
+		{
+			var result = Get(preferredModelName, preferredService);
+			if (result == null)
+				throw new Exception($"Model='{preferredModelName}' service='{preferredService}' not registered");
+			return result;
+		}
+	}
+
+	public class LlmServiceFactory : ILlmServiceFactory
+	{
+		private readonly List<LlmModelSpecification> models;
+		private readonly List<LlmServiceSpecification> serviceConfigs;
+		private readonly Func<HttpClient> httpClientFactory;
+
+		public LlmServiceFactory(IEnumerable<LlmModelSpecification> models, IEnumerable<LlmServiceSpecification> serviceConfigs, Func<HttpClient> httpClientFactory)
+		{
+			this.models = models.ToList();
+			this.serviceConfigs = serviceConfigs.ToList();
+			this.httpClientFactory = httpClientFactory;
+		}
+
+		public ILlmService? Get(string? preferredModelName = null, string? preferredService = null)
+		{
+			LlmModelSpecification? model = null;
+			LlmServiceSpecification? service = null;
+
+			if (preferredModelName != null)
+				model = models.FirstOrDefault(o => o.Name.Equals(preferredModelName ?? "", StringComparison.OrdinalIgnoreCase));
+			else if (preferredService != null)
+				service = serviceConfigs.First(o => o.Name == preferredService);
+
+			if (model == null && service == null)
+			{
+				model = models.FirstOrDefault();
+				if (model == null)
+					return null;
+			}
+
+			if (model == null)
+				model = models.FirstOrDefault(o => o.AvailableOnServices.Contains(service.Name));
+			else if (service == null)
+				service = serviceConfigs.FirstOrDefault(o => model.AvailableOnServices.Contains(o.Name));
+
+			if (model == null || service == null || model.AvailableOnServices.Contains(service.Name) == false)
+				return null;
+
+			return service.Name switch
+			{
+				"Azure" => new AzureOpenAIRESTService(model, service),
+				//"AzureREST" => new AzureRESTLlmService(model, service, httpClientFactory),
+				//"Berget" => new BergetLlmService(model, service, httpClientFactory),
+				_ => throw new NotImplementedException($"Service {service.Name}")
+			};
+		}
+	}
 	// Temp until common nuget
 	public interface ILlmService
 	{
@@ -12,7 +75,6 @@ public interface ILlmService
 	}
 	public record LlmContentReceivedData(string ContentSinceLast, int TotalLength);
 
-
 	public class LlmModelSpecification
 	{
 		public List<string> AvailableOnServices { get; set; } = new();
@@ -45,6 +107,17 @@ public class LlmResult
 		public string Model { get; set; } = "";
 	}
 
+	public class NullLlmService : ILlmService
+	{
+		public LlmModelSpecification ModelSpecification => new LlmModelSpecification();
+
+		public int CountTokens(string text) => 0;
+
+		public Task<LlmResult?> Invoke(string prompt, LlmCallOptions? options = null)
+			=> Task.FromResult((LlmResult?)new LlmResult { Completion = "" });
+	}
+
+
 	public class AzureOpenAIRESTService : ILlmService
 	{
 		private readonly Config config;

Common/Common.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>