Merge branch 'master' into task/#13_loggerredesign

Author: StuartFerguson

Shared.EventStore/EventStore/AggregateRepositoryManager.cs

@@ -0,0 +1,47 @@
+namespace Shared.EventStore.EventStore
+{
+    using System;
+    using DomainDrivenDesign.EventStore;
+
+    public class AggregateRepositoryManager : IAggregateRepositoryManager
+    {
+        #region Fields
+
+        /// <summary>
+        /// The event store context manager
+        /// </summary>
+        private readonly IEventStoreContextManager EventStoreContextManager;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateRepositoryManager" /> class.
+        /// </summary>
+        /// <param name="eventStoreContextManager">The event store context manager.</param>
+        public AggregateRepositoryManager(IEventStoreContextManager eventStoreContextManager)
+        {
+            this.EventStoreContextManager = eventStoreContextManager;
+        }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Gets the aggregate repository.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="identifier">The identifier.</param>
+        /// <returns></returns>
+        public IAggregateRepository<T> GetAggregateRepository<T>(Guid identifier) where T : Aggregate, new()
+        {
+            IEventStoreContext context = this.EventStoreContextManager.GetEventStoreContext(identifier.ToString());
+
+            return new AggregateRepository<T>(context);
+        }
+
+        #endregion
+    }
+}

Shared.EventStore/EventStore/EventStoreContextManager.cs

@@ -0,0 +1,151 @@
+namespace Shared.EventStore.EventStore
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading;
+    using DomainDrivenDesign.EventStore;
+    using Microsoft.Extensions.Logging;
+    using Repositories;
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <seealso cref="Shared.EventStore.EventStore.IEventStoreContextManager" />
+    public class EventStoreContextManager : IEventStoreContextManager
+    {
+        #region Fields
+
+        /// <summary>
+        /// The connection string configuration repository
+        /// </summary>
+        private readonly IConnectionStringConfigurationRepository ConnectionStringConfigurationRepository;
+
+        /// <summary>
+        /// The context
+        /// </summary>
+        private readonly IEventStoreContext Context;
+
+        /// <summary>
+        /// The event store context function
+        /// </summary>
+        private readonly Func<String, IEventStoreContext> EventStoreContextFunc;
+
+        /// <summary>
+        /// The event store contexts
+        /// </summary>
+        private readonly Dictionary<String, IEventStoreContext> EventStoreContexts;
+
+        //TODO static?
+        /// <summary>
+        /// The padlock
+        /// </summary>
+        private readonly Object padlock = new Object();
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EventStoreContextManager" /> class.
+        /// </summary>
+        /// <param name="eventStoreContextFunc">The event store context function.</param>
+        /// <param name="connectionStringConfigurationRepository">The connection string configuration repository.</param>
+        public EventStoreContextManager(Func<String, IEventStoreContext> eventStoreContextFunc,
+                                        IConnectionStringConfigurationRepository connectionStringConfigurationRepository)
+        {
+            this.EventStoreContexts = new Dictionary<String, IEventStoreContext>();
+            this.EventStoreContextFunc = eventStoreContextFunc;
+            this.ConnectionStringConfigurationRepository = connectionStringConfigurationRepository;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EventStoreContextManager" /> class.
+        /// </summary>
+        /// <param name="eventStoreContext">The event store context.</param>
+        public EventStoreContextManager(IEventStoreContext eventStoreContext)
+        {
+            this.Context = eventStoreContext;
+        }
+
+        #endregion
+
+        #region Events
+
+        /// <summary>
+        /// Occurs when [trace generated].
+        /// </summary>
+        public event TraceHandler TraceGenerated;
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Gets the event store context.
+        /// </summary>
+        /// <param name="connectionIdentifier">The connection identifier.</param>
+        /// <returns></returns>
+        public IEventStoreContext GetEventStoreContext(String connectionIdentifier)
+        {
+            if (this.Context != null)
+            {
+                return this.Context;
+            }
+
+            this.WriteTrace($"No resolved context found, about to resolve one using connectionIdentifier {connectionIdentifier}");
+
+            if (this.EventStoreContexts.ContainsKey(connectionIdentifier))
+            {
+                return this.EventStoreContexts[connectionIdentifier];
+            }
+
+            this.WriteTrace($"Creating a new EventStoreContext for connectionIdentifier {connectionIdentifier}");
+
+            lock(this.padlock)
+            {
+                if (!this.EventStoreContexts.ContainsKey(connectionIdentifier))
+                {
+                    // This will need to now look up the ES Connection string from persistence
+                    String connectionString = this.ConnectionStringConfigurationRepository
+                                                  .GetConnectionString(connectionIdentifier, ConnectionStringType.EventStore, CancellationToken.None).Result;
+
+                    this.WriteTrace($"Connection String is {connectionString}");
+
+                    IEventStoreContext eventStoreContext = this.EventStoreContextFunc(connectionString);
+
+                    this.EventStoreContexts.Add(connectionIdentifier, eventStoreContext);
+                }
+
+                return this.EventStoreContexts[connectionIdentifier];
+            }
+        }
+
+        /// <summary>
+        /// Guards the against no connection identifier.
+        /// </summary>
+        /// <param name="connectionIdentifier">The connection identifier.</param>
+        /// <exception cref="ArgumentException">Value cannot be empty. - connectionIdentifier</exception>
+        private void GuardAgainstNoConnectionIdentifier(String connectionIdentifier)
+        {
+            //Check if the connectionStringIdentifier is present
+            if (string.IsNullOrEmpty(connectionIdentifier))
+            {
+                throw new ArgumentException("Value cannot be empty.", nameof(connectionIdentifier));
+            }
+        }
+
+        /// <summary>
+        /// Writes the trace.
+        /// </summary>
+        /// <param name="trace">The trace.</param>
+        private void WriteTrace(String trace)
+        {
+            if (this.TraceGenerated != null)
+            {
+                this.TraceGenerated(trace, LogLevel.Information);
+            }
+        }
+
+        #endregion
+    }
+}

Shared.EventStore/EventStore/IAggregateRepositoryManager.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Shared.EventStore.EventStore
+{
+    using DomainDrivenDesign.EventStore;
+
+    public interface IAggregateRepositoryManager
+    {
+        #region Methods
+
+        /// <summary>
+        /// Gets the aggregate repository.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="identifier">The identifier.</param>
+        /// <returns></returns>
+        IAggregateRepository<T> GetAggregateRepository<T>(Guid identifier) where T : Aggregate, new();
+
+        #endregion
+    }
+}

Shared.EventStore/EventStore/IEventStoreContextManager.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Text;
+
+namespace Shared.EventStore.EventStore
+{
+    using System.Diagnostics;
+    using DomainDrivenDesign.EventStore;
+
+    public interface IEventStoreContextManager
+    {
+        IEventStoreContext GetEventStoreContext(String connectionIdentifier);
+    }
+}

Shared.EventStore/Shared.EventStore.csproj

@@ -12,6 +12,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\Shared.DomainDrivenDesign\Shared.DomainDrivenDesign.csproj" />
+    <ProjectReference Include="..\Shared\Shared.csproj" />
   </ItemGroup>
 
 </Project>

Shared/EntityFramework/ConnectionStringConfiguration/ConnectionStringConfiguration.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Text;
+
+namespace Shared.EntityFramework.ConnectionStringConfiguration
+{
+    using System.ComponentModel.DataAnnotations.Schema;
+
+    public class ConnectionStringConfiguration
+    {
+        /// <summary>
+        /// Gets or sets the identifier.
+        /// </summary>
+        /// <value>
+        /// The identifier.
+        /// </value>
+        [Key]
+        public Guid Id { get; set; }
+
+        /// <summary>
+        /// Gets or sets the connection string identifier.
+        /// </summary>
+        /// <value>
+        /// The connection string identifier.
+        /// </value>
+        [Required]
+        [Column("externalIdentifier")]
+        public String ExternalIdentifier { get; set; }
+
+        /// <summary>
+        /// Gets or sets the connection string type identifier.
+        /// </summary>
+        /// <value>
+        /// The connection string type identifier.
+        /// </value>
+        public Int32 ConnectionStringTypeId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the type of the connection string.
+        /// </summary>
+        /// <value>
+        /// The type of the connection string.
+        /// </value>
+        [ForeignKey(nameof(ConnectionStringTypeId))]
+        public virtual ConnectionStringType ConnectionStringType { get; set; }
+
+
+        /// <summary>
+        /// Gets or sets the connection string.
+        /// </summary>
+        /// <value>
+        /// The connection string.
+        /// </value>
+        [Required]
+        [Column("connectionString")]
+        public String ConnectionString { get; set; }
+    }
+}