Initial development

.dockerignore

@@ -0,0 +1,30 @@
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md
+!**/.gitignore
+!.git/HEAD
+!.git/config
+!.git/packed-refs
+!.git/refs/heads/**

EventJournal.CLI/CLIUtilities.cs

@@ -0,0 +1,50 @@
+namespace EventJournal.CLI {
+    public static class CLIUtilities {
+        public static string GetStringFromUser(string prompt) {
+            string? userInput = null;
+
+            while (string.IsNullOrWhiteSpace(userInput)) {
+                Console.Write(prompt);
+                userInput = Console.ReadLine();
+            }
+            return userInput;
+        }
+
+        public static int GetIntFromUser(string prompt) {
+            var intFromUser = 0;
+
+            var isInvalidInput = true;
+            while (isInvalidInput) {
+                Console.Write(prompt);
+                isInvalidInput = !int.TryParse(Console.ReadLine(),
+                    System.Globalization.NumberStyles.AllowLeadingWhite
+                    | System.Globalization.NumberStyles.AllowTrailingWhite,
+                    System.Globalization.CultureInfo.CurrentCulture,
+                    out intFromUser);
+                if (isInvalidInput) {
+                    Console.WriteLine("Must be an integer.");
+                }
+            }
+
+            return intFromUser;
+        }
+
+        public static decimal GetDecimalFromUser(string prompt) {
+            var decimalFromUser = 0.0M;
+            var isInvalidInput = true;
+            while (isInvalidInput) {
+                Console.Write(prompt);
+                isInvalidInput = !decimal.TryParse(Console.ReadLine(),
+                    System.Globalization.NumberStyles.AllowLeadingWhite
+                    | System.Globalization.NumberStyles.AllowTrailingWhite
+                    | System.Globalization.NumberStyles.Currency,
+                    System.Globalization.CultureInfo.CurrentCulture,
+                    out decimalFromUser);
+                if (isInvalidInput) {
+                    Console.WriteLine("Must be a number.");
+                }
+            }
+            return decimalFromUser;
+        }
+    }
+}

EventJournal.CLI/DesignTimeDbContextFactory.cs

@@ -0,0 +1,24 @@
+using EventJournal.Common.Configuration;
+using EventJournal.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+using Microsoft.Extensions.Configuration;
+
+namespace EventJournal.CLI {
+    public class DesignTimeDbContextFactory : IDesignTimeDbContextFactory<DatabaseContext> {
+        public DatabaseContext CreateDbContext(string[] args) {
+            IConfiguration configuration = new ConfigurationBuilder()
+                .SetBasePath(Directory.GetCurrentDirectory())
+                .AddJsonFile("appsettings.json")
+                .Build();
+
+            var dbSettings = configuration.GetSection(DatabaseSettings.ConfigurationSectionName).Get<DatabaseSettings>()
+                ?? throw new InvalidOperationException("Configuration settings does not contain a valid DatabaseSettings section.");
+
+            var builder = new DbContextOptionsBuilder<DatabaseContext>();
+            DatabaseContext.ConfigureFromSettings(builder, dbSettings);
+
+            return new DatabaseContext(builder.Options);
+        }
+    }
+}

EventJournal.CLI/EventJournal.CLI.csproj

@@ -0,0 +1,39 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+    <RootNamespace>EventJournal.CLI</RootNamespace>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="AsyncFixer" Version="1.6.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.11">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.Extensions.Configuration" Version="9.0.11" />
+    <PackageReference Include="Microsoft.VisualStudio.Threading.Analyzers" Version="17.14.15">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Eventjournal.Bootstrap\EventJournal.BootStrap.csproj" />
+    <ProjectReference Include="..\EventJournal.Data\EventJournal.Data.csproj" />
+    <ProjectReference Include="..\EventJournal.DomainService\EventJournal.DomainService.csproj" />
+    <ProjectReference Include="..\EventJournal.Models\EventJournal.PublicModels.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+</Project>

EventJournal.CLI/Program.cs

@@ -0,0 +1,119 @@
+// See https://aka.ms/new-console-template for more information
+using EventJournal.BootStrap;
+using EventJournal.CLI;
+using EventJournal.Common.Bootstrap;
+using EventJournal.DomainService;
+using EventJournal.PublicModels;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using System.Text.Json;
+internal class Program {
+    private static async Task Main(string[] args) {
+
+        var services = CreateServiceCollection();
+        var eventService = services.GetService<IEventService>() ?? throw new Exception("Unable to locate a valid Event Service");
+        var userTypeService = services.GetService<IUserTypesService>() ?? throw new Exception("Unable to locate a valid User Types Service");
+        var defaultDataProvider = services.GetService<IDefaultDataProvider>() ?? throw new Exception("Unable to locate a valid Default Data Provider");
+        var jsonSerializerOptions = services.GetService<JsonSerializerOptions>() ?? throw new Exception("Unable to locate a valid Json Serializer Options");
+        bool userIsDone = false;
+        while (!userIsDone) {
+            //Console.WriteLine("Type '1' to ");
+            //Console.WriteLine("Type '2' to ");
+            //Console.WriteLine("Type '3' to ");
+            //Console.WriteLine("Type '4' to ");
+            //Console.WriteLine("Type '6' to ");
+            //Console.WriteLine("Type '7' to ");
+            //Console.WriteLine("Type '8' to ");
+
+            Console.WriteLine("Type 'v' to view all data");
+            Console.WriteLine("Type 't' to add default test data.");
+            Console.WriteLine("Type 'x' to delete all data.");
+            Console.WriteLine("Type 'q' to quit.");
+
+            // application will block here waiting for user to press <Enter>
+            var userInput = CLIUtilities.GetStringFromUser("===> ").ToLower() ?? "";
+
+            switch (userInput[0]) {
+                case 'q':
+                    userIsDone = true;
+                    break;
+                //    case '1':
+                //        await AddUpdateEntity(GetEntityFromUser<Product>()).ConfigureAwait(false);
+                //        break;
+                //    case '2':
+                //        await ViewProduct().ConfigureAwait(false);
+                //        break;
+                //    case '3':
+                //        await ViewInStockProducts().ConfigureAwait(false);
+                //        break;
+                //    case '4':
+                //        await ViewAllProduct().ConfigureAwait(false);
+                //        break;
+                //    case '5':
+
+                //        break;
+                //    case '6':
+                //        await AddUpdateEntity(GetEntityFromUser<Order>()).ConfigureAwait(false);
+                //        break;
+                //    case '7':
+                //        await ViewOrder().ConfigureAwait(false);
+                //        break;
+                //case '8':
+                //    break;
+                //case '9':
+                //    break;
+                case 'v':
+                    await ViewallDataAsync(jsonSerializerOptions, eventService, userTypeService).ConfigureAwait(false);
+                    break;
+                case 't':
+                    await AddTestDataAsync(defaultDataProvider).ConfigureAwait(false);
+                    break;
+                case 'x':
+                    await DeleteAllDataAsync(eventService, userTypeService).ConfigureAwait(false);
+                    break;
+            }
+            Console.WriteLine("\n=================================================\n");
+        }
+    }
+
+    private static ServiceProvider CreateServiceCollection() {
+        IConfiguration Configuration = new ConfigurationBuilder()
+            .SetBasePath(Directory.GetCurrentDirectory())
+            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
+            .Build();
+
+        return new ServiceCollection()
+                // setup and register bootstrapper and it's installers -- needs to be last
+                .AddBootStrapper<DefaultApplicationBootStrapper>(Configuration, o => {
+                    // Add any application specific installers here.
+                }).BuildServiceProvider();
+    }
+
+    static Task AddTestDataAsync(IDefaultDataProvider defaultDataProvider) {
+        Console.WriteLine("Adding/Resetting test data.");
+        return defaultDataProvider.AddResetDefaultDataAsync();
+    }
+    static async Task DeleteAllDataAsync(IEventService eventService, IUserTypesService userTypeService) {
+
+        Console.WriteLine("Deleting all data.");
+        foreach (var e in await eventService.GetAllEventsAsync().ConfigureAwait(false)) {
+            await eventService.DeleteEventAsync(e.ResourceId).ConfigureAwait(false);
+        }
+        foreach (var e in await userTypeService.GetAllEventTypesAsync().ConfigureAwait(false)) {
+            await userTypeService.DeleteEventTypeAsync(e.ResourceId).ConfigureAwait(false);
+        }
+        foreach (var e in await userTypeService.GetAllDetailTypesAsync().ConfigureAwait(false)) {
+            await userTypeService.DeleteDetailTypeAsync(e.ResourceId).ConfigureAwait(false);
+        }
+    }
+
+    static async Task ViewallDataAsync(JsonSerializerOptions options, IEventService eventService, IUserTypesService userTypeService) {
+        EventDataResponseModel eventData = new() {
+            DetailTypes = await userTypeService.GetAllDetailTypesAsync().ConfigureAwait(false),
+            EventTypes = await userTypeService.GetAllEventTypesAsync().ConfigureAwait(false),
+            Events = await eventService.GetAllEventsAsync().ConfigureAwait(false)
+        };
+
+        Console.WriteLine(JsonSerializer.Serialize(eventData, options));
+    }
+}

EventJournal.CLI/appsettings.json

@@ -0,0 +1,14 @@
+{
+  // Configuration settings for the EventJournal.CLI application
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "Database": {
+    //"ConnectionString": "Server=myServer;Database=myDatabase;User ID=myUser;Password=myPassword;",
+    "ConnectionString": "Default",
+    "Provider": "Sqlite"
+  }
+}

EventJournal.Common/Bootstrap/BootStrapper.cs

@@ -0,0 +1,104 @@
+using EventJournal.Common.IOC;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventJournal.Common.Bootstrap {
+    public class BootStrapper {
+        protected IList<IInstaller> installers;
+
+        public BootStrapper() {
+            installers = [];
+        }
+
+        public virtual void AddInstaller(IInstaller installer) {
+            ArgumentNullException.ThrowIfNull(installer, nameof(installer));
+            installers.Add(installer);
+        }
+        /// <summary>
+        /// Installs all of the specified installers, overriding the internal list of installers.
+        /// </summary>
+        /// <param name="installers">A list of installers to register with the IoC.</param>
+        public virtual IServiceProvider InitIoCContainer(params IInstaller[] installers) {
+            if (installers == null) {
+                throw new ArgumentNullException(nameof(installers), "Installers cannot be null");
+            }
+            IServiceProvider container = InternalInitialize(installers);
+            return container;
+        }
+
+        /// <summary>
+        /// Installs all the internally specified installers, while adding the [applicationInstaller]
+        /// </summary>
+        /// <param name="applicationInstaller">The additional installer for the root level application.</param>
+        public virtual IServiceProvider InitIoCContainer(IInstaller applicationInstaller) {
+            if (applicationInstaller == null) {
+                throw new ArgumentNullException(nameof(applicationInstaller), "Application installer cannot be null");
+            }
+            installers.Add(applicationInstaller);
+            return InternalInitialize([.. installers]);
+        }
+
+        public virtual IServiceProvider InitIoCContainer() {
+            return InternalInitialize([.. installers]);
+        }
+
+        public virtual IServiceProvider InitIoCContainer(IServiceCollection services) {
+            if (services == null) {
+                throw new ArgumentNullException(nameof(services), "Service collection cannot be null");
+            }
+            return InternalInitialize(services, [.. installers]);
+        }
+
+        public virtual IServiceProvider InitIoCContainer(IConfigurationBuilder config, IServiceCollection services) {
+            if (config == null) {
+                throw new ArgumentNullException(nameof(config), "Configuration builder cannot be null");
+            }
+            return InternalInitialize(config, services, [.. installers]);
+        }
+        public virtual IServiceProvider InitIoCContainer(IConfiguration configuration, IServiceCollection services) {
+            if (configuration == null) {
+                throw new ArgumentNullException(nameof(configuration), "Configuration cannot be null");
+            }
+            if (services == null) {
+                throw new ArgumentNullException(nameof(services), "Service collection cannot be null");
+            }
+            return InternalInitialize(configuration, services, [.. installers]);
+        }
+
+        protected internal virtual IServiceProvider InternalInitialize(IInstaller[] installers) {
+            var services = new ServiceCollection().AddOptions();
+            return InternalInitialize(services, installers);
+        }
+
+        protected internal virtual IServiceProvider InternalInitialize(IConfigurationBuilder config, IInstaller[] installers) {
+            var services = new ServiceCollection().AddOptions();
+            return InternalInitialize(config, services, installers);
+        }
+
+        protected internal virtual IServiceProvider InternalInitialize(IServiceCollection services, IInstaller[] installers) {
+            var configuration = new ConfigurationBuilder()
+                .AddJsonFile("appsettings.json");
+            return InternalInitialize(configuration, services, installers);
+        }
+
+        protected internal virtual IServiceProvider InternalInitialize(IConfigurationBuilder config, IServiceCollection services, IInstaller[] installers) {
+            var configuration = config.Build();
+            return InternalInitialize(configuration, services, installers);
+        }
+
+        protected internal virtual IServiceProvider InternalInitialize(IConfiguration configuration, IServiceCollection services, IInstaller[] installers) {
+            DI.SetConfiguration(configuration);
+
+            foreach (var i in installers) {
+                   i.Install(services, configuration);
+            }
+
+            services.AddSingleton<IConfiguration>(configuration);
+            var serviceProvider = services.BuildServiceProvider();
+
+            DI.SetContainer(serviceProvider);
+            return serviceProvider;
+        }
+    }
+
+}