v3 beta

Author: gauffininteractive

.gitignore

@@ -38,3 +38,4 @@ src/Server/Coderr.Server.Web.Tests/applicationhost.config
 /src/Server/Coderr.Server.Web/wwwroot/dist/**
 /src/Server/Coderr.Server.Web/npm-shrinkwrap.json
 /src/Server/node_modules/**
+/src/Server/Coderr.Server.WebSite/ClientApp/.angular/

src/Server/Coderr.Server.Abstractions/Boot/ConfigurationContext.cs

@@ -8,12 +8,19 @@ namespace Coderr.Server.Abstractions.Boot
 {
     public abstract class ConfigurationContext
     {
+        protected ConfigurationContext(IServiceCollection services, Func<IServiceProvider> serviceProvider)
+        {
+            Services = services;
+            ServiceProvider = serviceProvider;
+        }
 
         public Func<ClaimsPrincipal, IDbConnection> ConnectionFactory { get; set; }
-        public IServiceCollection Services { get; set; }
-        public Func<IServiceProvider> ServiceProvider { get; set; }
+        public IServiceCollection Services { get; private set; }
+        public Func<IServiceProvider> ServiceProvider { get; private set; }
         public IConfiguration Configuration { get; set; }
 
         public abstract void RegisterMessageTypes(Assembly assembly);
+
+        public abstract ConfigurationContext Clone(IServiceCollection serviceCollection);
     }
 }

src/Server/Coderr.Server.Abstractions/Boot/IConfiguration.cs

@@ -4,6 +4,7 @@ namespace Coderr.Server.Abstractions.Boot
 {
     public interface IConfiguration 
     {
+        string this[string name] { get; }
         IConfigurationSection GetSection(string name);
         string GetConnectionString(string name);
         IEnumerable<IConfigurationSection> GetChildren();

src/Server/Coderr.Server.Abstractions/Boot/RegisterExtensions.cs

@@ -1,40 +1,54 @@
 using System;
+using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
+using System.Security.Cryptography.X509Certificates;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Coderr.Server.Abstractions.Boot
 {
     public static class RegisterExtensions
     {
+
         public static void RegisterContainerServices(this IServiceCollection serviceCollection, Assembly assembly)
         {
-            var containerServices = assembly.GetTypes();
+            var gotWrongAttribute = (
+                from type in assembly.GetTypes()
+                let attributes = type.GetCustomAttributes()
+                where attributes.Count(x => x.GetType().FullName == "Griffin.Container.ContainerService") > 0
+                select type).ToList();
+            if (gotWrongAttribute.Count > 0)
+            {
+                throw new InvalidOperationException(
+                    $"Types \'{string.Join(",", gotWrongAttribute)}\' was decorated with the wrong attribute");
+            }
+
+            var containerServices = assembly.GetTypes()
+                .Where(x => x.GetCustomAttribute<ContainerServiceAttribute>() != null);
+
             foreach (var containerService in containerServices)
             {
-                var gotWrongAttribute = containerService
-                    .GetCustomAttributes()
-                    .Count(x => x.GetType().FullName == "Griffin.Container.ContainerService") == 1;
-                if (gotWrongAttribute)
-                {
-                    throw new InvalidOperationException(
-                        $"Type \'{containerService}\' was decorated with the wrong attribute");
-                    ;
-                }
+                Debug.WriteLine(Assembly.GetCallingAssembly().GetName().Name + " registers " + containerService.FullName);
 
                 var attr = containerService.GetCustomAttribute<ContainerServiceAttribute>();
-                if (attr == null)
-                    continue;
-
                 var interfaces = containerService.GetInterfaces();
+                var lifetime = ConvertLifetime(attr);
 
                 // Hack so that the same instance is resolved for each interface
+                bool isRegisteredAsSelf = false;
                 if (interfaces.Length > 1 || attr.RegisterAsSelf)
-                    serviceCollection.RegisterService(attr, containerService, containerService);
+                {
+                    serviceCollection.Add(new ServiceDescriptor(containerService, containerService, lifetime));
+                    isRegisteredAsSelf=true;
+                }
+                    
 
                 foreach (var @interface in interfaces)
                 {
-                    serviceCollection.RegisterService(attr, @interface, containerService);
+                    var sd = isRegisteredAsSelf
+                        ? new ServiceDescriptor(@interface, x => x.GetService(containerService), lifetime) // else we don't get the same instance in the scope.
+                        : new ServiceDescriptor(@interface, containerService, lifetime);
+                    serviceCollection.Add(sd);
                 }
             }
         }
@@ -47,27 +61,33 @@ public static void RegisterMessageHandlers(this IServiceCollection serviceCollec
                 .ToList();
             foreach (var type in types)
             {
+                Debug.WriteLine(Assembly.GetCallingAssembly().GetName().Name + " registers " + type.FullName);
+
                 serviceCollection.AddScoped(type, type);
 
                 var ifs = type.GetInterfaces()
                     .Where(x => x.Name.Contains("IMessageHandler") || x.Name.Contains("IQueryHandler"))
                     .ToList();
                 foreach (var @if in ifs)
                 {
-                    serviceCollection.AddScoped(@if, type);
+                    serviceCollection.AddScoped(@if, x => x.GetService(type));
                 }
             }
         }
 
-        private static void RegisterService(this IServiceCollection serviceCollection, ContainerServiceAttribute attr,
-            Type service, Type implementation)
+        private static ServiceLifetime ConvertLifetime(ContainerServiceAttribute attr)
         {
             if (attr.IsSingleInstance)
-                serviceCollection.AddSingleton(service, implementation);
-            else if (attr.IsTransient)
-                serviceCollection.AddTransient(service, implementation);
-            else
-                serviceCollection.AddScoped(service, implementation);
+            {
+                return ServiceLifetime.Singleton;
+            }
+
+            if (attr.IsTransient)
+            {
+                return ServiceLifetime.Transient;
+            }
+
+            return ServiceLifetime.Scoped;
         }
     }
 }

src/Server/Coderr.Server.Abstractions/Coderr.Server.Abstractions.csproj

@@ -2,14 +2,19 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <Configurations>Debug;Release;Premise</Configurations>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\Coderr.Server.Api\Coderr.Server.Api.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="2.2.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.22" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Tags\" />
   </ItemGroup>
 
 

src/Server/Coderr.Server.Abstractions/HostConfig.cs

@@ -1,27 +1,54 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
+using System.Diagnostics;
 
 namespace Coderr.Server.Abstractions
 {
     /// <summary>
-    /// Wraps either the configuration file or the Docker environment variables.
+    ///     Wraps either the configuration file or the Docker environment variables.
     /// </summary>
     public class HostConfig
     {
         public static HostConfig Instance = new HostConfig();
 
+        private static bool _isTriggered;
+
         public bool IsRunningInDocker { get; set; }
         public string ConnectionString { get; set; }
-        public bool IsConfigured { get; set; }
-        public string ConfigurationPassword { get; set; }
+
+        public bool IsDemo { get; set; } = Debugger.IsAttached;
+        public bool IsConfigured { get; private set; }
+
+        /// <summary>
+        ///     Just to make it harder to take over an ongoing installation of Coderr on a public ip. Changed now and then.
+        /// </summary>
+        public string InstallationPassword { get; set; }
+
+        public event EventHandler Configured;
 
         public override string ToString()
         {
             var tmp = IsRunningInDocker ? "[DOCKER] " : "[NATIVE] ";
-            return IsConfigured
-                ? $"{tmp} running with {ConnectionString}"
-                : $"{tmp} Will configure with password {ConfigurationPassword} and using {ConnectionString}";
+            return $"{tmp} running with {ConnectionString}";
+        }
+
+        /// <summary>
+        ///     Mark configuration as complete.
+        /// </summary>
+        public void MarkAsConfigured()
+        {
+            IsConfigured = true;
+        }
+
+        /// <summary>
+        ///     Separate method since it must be run after everyone have subscribed on the event.
+        /// </summary>
+        public void TriggeredConfigured()
+        {
+            if (_isTriggered) return;
+
+            _isTriggered = true;
+            IsConfigured = true;
+            Configured?.Invoke(this, EventArgs.Empty);
         }
     }
-}
+}

src/Server/Coderr.Server.Abstractions/IConnectionFactory.cs

@@ -1,10 +1,11 @@
 using System.Data;
+using System.Security.Claims;
 
 namespace Coderr.Server.Abstractions
 {
     public interface IConnectionFactory
     {
-        IDbConnection OpenConnection();
-        bool IsConfigured { get; set; }
+        IDbConnection OpenConnection(ClaimsPrincipal principal);
+        
     }
 }

src/Server/Coderr.Server.Abstractions/IGotTransaction.cs

@@ -0,0 +1,9 @@
+using System.Data.Common;
+
+namespace Coderr.Server.Abstractions
+{
+    public interface IGotTransaction
+    {
+        DbTransaction Transaction { get; }
+    }
+}

src/Server/Coderr.Server.Abstractions/QueueConfig.cs

@@ -0,0 +1,36 @@
+using System;
+using Coderr.Server.Abstractions.Boot;
+
+namespace Coderr.Server.Abstractions
+{
+    public class QueueConfig
+    {
+        public string ReportQueue { get; set; }
+        public string InboundPartitions { get; set; }
+        public string ReportEventQueue { get; set; }
+        public string AppQueue { get; set; }
+
+        public void Configure(IConfiguration config)
+        {
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            if (ServerConfig.Instance.IsLive)
+            {
+                ReportQueue = config.GetSection("MessageQueue")["ReportQueue"];
+                ReportEventQueue = config.GetSection("MessageQueue")["ReportEventQueue"];
+                AppQueue = config.GetSection("MessageQueue")["AppQueue"];
+                InboundPartitions = config.GetSection("MessageQueue")["InboundPartitions"];
+            }
+            else
+            {
+                ReportQueue = "ErrorReports";
+                ReportEventQueue = "ErrorReportEvents";
+                AppQueue = "Messaging";
+                InboundPartitions = "InboundPartitions";
+            }
+        }
+    }
+}

src/Server/Coderr.Server.Abstractions/Reports/ReportConfig.cs

@@ -49,6 +49,11 @@ public ReportConfig()
         /// </remarks>
         public int RetentionDays { get; set; }
 
+        /// <summary>
+        /// Number of days to store incidents that have not received any new reports.
+        /// </summary>
+        public int RetentionDaysIncidents { get; set; }
+
         string IConfigurationSection.SectionName => "ReportConfig";
 
         IDictionary<string, string> IConfigurationSection.ToDictionary()
@@ -61,6 +66,8 @@ void IConfigurationSection.Load(IDictionary<string, string> settings)
             this.AssignProperties(settings);
             if (MaxReportJsonSize == 0)
                 MaxReportJsonSize = 1000000;
+            if (RetentionDaysIncidents == 0)
+                RetentionDaysIncidents = 90;
         }
     }
 }