Change to domain driven events.

Author: RobertPepkaSEL

.gitignore

@@ -0,0 +1,109 @@
+using Heimdall.Logic.Core;
+using Heimdall.Logic.WorkInstructions;
+using Heimdall.Logic.WorkInstructions.Commands;
+using Heimdall.Logic.WorkInstructions.Entities;
+using Heimdall.Logic.WorkInstructions.Events;
+using Microsoft.EntityFrameworkCore;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Query.ExpressionTranslators.Internal;
+using OneOf;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Heimdall.Data.Accessors
+{
+    internal class WorkInstructionAccessor : IWorkInstructionAccessor
+    {
+        private readonly WorkInstructionDatabaseContext _context;
+
+        public WorkInstructionAccessor(WorkInstructionDatabaseContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<OneOf<WorkInstructionCreated, CreateWorkInstructionFailed>> AddAsync(CreateWorkInstruction command)
+        {
+            var workInstruction = new WorkInstruction()
+            {
+
+                Title = command.Title,
+                Description = command.Description,
+                InstructionObject = command.InstructionObject,
+            };
+            try
+            {
+                _context.WorkInstructions.Add(workInstruction);
+                await _context.SaveChangesAsync();
+                return new WorkInstructionCreated(workInstruction);
+            }
+            catch (Exception ex)
+            {
+                return new CreateWorkInstructionFailed(command, ex.Message);
+            }
+        }
+
+        public async Task<OneOf<WorkInstructionDeleted, DeleteWorkInstructionFailed>> DeleteAsync(DeleteWorkInstruction command)
+        {
+            var workInstruction = await _context.WorkInstructions.FindAsync(command.Id);
+
+            if (workInstruction is null)
+            {
+                return new DeleteWorkInstructionFailed(command, $"Could not find work instruction with id {command.Id}");
+            }
+
+            _context.Remove(workInstruction);
+            await _context.SaveChangesAsync();
+
+            return new WorkInstructionDeleted(command.Id);
+        }
+
+        public async Task<OneOf<WorkInstructionsRead, WorkInstructionNotFound>> GetAllAsync()
+        {
+            WorkInstruction[] databaseInstructions = (await _context.WorkInstructions.ToArrayAsync()) ?? Array.Empty<WorkInstruction>();
+            
+            return new WorkInstructionsRead(databaseInstructions);
+        }
+
+        public async Task<OneOf<WorkInstructionRead, WorkInstructionNotFound>> GetAsync(ReadWorkInstruction command)
+        {
+            WorkInstruction? workInstruction = await _context.WorkInstructions.FindAsync(command.Id);
+            if (workInstruction is null)
+            {
+                return new WorkInstructionNotFound(command.Id);
+            }
+
+            return new WorkInstructionRead(workInstruction);
+        }
+
+        public async Task<OneOf<WorkInstructionUpdated, UpdateWorkInstructionFailed>> UpdateAsync(UpdateWorkInstruction command)
+        {
+
+            var workInSet = await _context.WorkInstructions.FindAsync(command.Id);
+
+            // RLP - Fail early. Find bad cases, return, and continue with good cases.
+            if (workInSet is null)
+            {
+                return new UpdateWorkInstructionFailed(command, $"Unable to find Work Instruction with id {command.Id}");
+            }
+
+            if (command.Title is not null)
+            {
+                workInSet.Title = command.Title;
+            }
+            if (command.Description is not null)
+            {
+                workInSet.Description = command.Description;
+            }
+            if (command.InstructionObject is not null)
+            {
+                workInSet.InstructionObject = command.InstructionObject;
+            }
+
+            await _context.SaveChangesAsync();
+
+            return new WorkInstructionUpdated(workInSet);
+        }
+    }
+}

.vs/ProjectEvaluation/heimdall_web_api.metadata.v5.2

@@ -1,12 +1,19 @@
 using Heimdall.Data;
+using Heimdall.Logic.WorkInstructions.Entities;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 
-namespace heimdall_web_api.Configs
+namespace Heimdall.Data.EntityConfigurations
 {
-    public class WorkInstructionSetConfig : IEntityTypeConfiguration<WorkInstructionSet>
+    /// <summary>
+    /// Configuration for the <see cref="WorkInstruction"/>
+    /// </summary>
+    /// <remarks>
+    /// RLP - I'd encourage using the full name of the entity element that this extends (e.g., it's a configuration)
+    /// </remarks>
+    public class WorkInstructionConfiguration : IEntityTypeConfiguration<WorkInstruction>
     {
-        public void Configure(EntityTypeBuilder<WorkInstructionSet> builder)
+        public void Configure(EntityTypeBuilder<WorkInstruction> builder)
         {
             builder.HasKey(x => x.Id);
 

.vs/ProjectEvaluation/heimdall_web_api.projects.v5.2

@@ -7,9 +7,12 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="EntityFramework" Version="6.4.4" />
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.2" />
     <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="7.0.1" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\Heimdall.Logic\Heimdall.Logic.csproj" />
+  </ItemGroup>
+
 </Project>

.vs/heimdall_web_api/DesignTimeBuild/.dtbcache.v2

@@ -0,0 +1,28 @@
+using Heimdall.Data.Accessors;
+using Heimdall.Logic.WorkInstructions;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Heimdall.Data
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <remarks>
+    /// This lets your business logic decide what it makes available to dependency injection
+    /// without mucking up the Program.cs file.
+    /// </remarks>
+    public static class IServiceCollectionExtensions
+    {
+        public static IServiceCollection AddHeimdallData(this IServiceCollection services)
+        {
+            services.AddScoped<IWorkInstructionAccessor, WorkInstructionAccessor>();
+
+            return services;
+        }
+    }
+}

.vs/heimdall_web_api/FileContentIndex/4461e8f5-8afd-4a9f-b52c-8b777bcb420d.vsidx

@@ -1,10 +1,11 @@
 using Microsoft.EntityFrameworkCore;
-using heimdall_web_api.Configs;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Heimdall.Logic.WorkInstructions.Entities;
+using System.Reflection;
 
 namespace Heimdall.Data
 {
@@ -13,12 +14,14 @@ public class WorkInstructionDatabaseContext : DbContext
         public WorkInstructionDatabaseContext(DbContextOptions<WorkInstructionDatabaseContext> options) : base(options)
         {
         }
-        public DbSet<WorkInstructionSet> workInstructionSets { get; set; }
+
+        // RLP - use PascalCasing for entities. The word "Set" isn't needed to define a set.
+        public DbSet<WorkInstruction> WorkInstructions { get; set; }
 
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
-            new WorkInstructionSetConfig().Configure(modelBuilder.Entity<WorkInstructionSet>());
-            //now using IEntityTypeConfiguration to setup data accsess in a organized way
+            // RLP - There way will load all configurations in the entire assembly without having to specify them individually.
+            modelBuilder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());
         }
     }
 }