New Endpoint "getAssociatedPersonsWithtrust"

Dfe.Academies.Api.Infrastructure/InfrastructureServiceCollectionExtensions.cs

@@ -43,11 +43,11 @@ public static IServiceCollection AddPersonsApiInfrastructureDependencyGroup(
             services.AddScoped<ITrustRepository, TrustRepository>();
             services.AddScoped<IEstablishmentRepository, EstablishmentRepository>();
             services.AddScoped<IConstituencyRepository, ConstituencyRepository>();
-            services.AddScoped(typeof(IMstrRepository<,>), typeof(MstrRepository<,>));
-            services.AddScoped(typeof(IMopRepository<,>), typeof(MopRepository<,>));
 
             // Query Services
             services.AddScoped<IEstablishmentQueryService, EstablishmentQueryService>();
+            services.AddScoped<ITrustQueryService, TrustQueryService>();
+
 
             //Cache service
             services.Configure<CacheSettings>(config.GetSection("CacheSettings"));

Dfe.Academies.Api.Infrastructure/MstrContext.cs

@@ -28,6 +28,7 @@ public MstrContext(DbContextOptions<MstrContext> options) : base(options)
     public DbSet<IfdPipeline> IfdPipelines { get; set; } = null!;
     public DbSet<GovernanceRoleType> GovernanceRoleTypes { get; set; } = null!;
     public DbSet<EducationEstablishmentGovernance> EducationEstablishmentGovernances { get; set; } = null!;
+    public DbSet<TrustGovernance> TrustGovernances { get; set; } = null!;
 
 
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
@@ -57,6 +58,9 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 
             modelBuilder.Entity<GovernanceRoleType>(ConfigureGovernanceRoleType);
             modelBuilder.Entity<GovernanceRoleType>().Metadata.SetIsTableExcludedFromMigrations(false);
+
+            modelBuilder.Entity<TrustGovernance>(ConfigureTrustGovernance);
+            modelBuilder.Entity<TrustGovernance>().Metadata.SetIsTableExcludedFromMigrations(false);
         }
         else
         {
@@ -65,6 +69,9 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
 
             modelBuilder.Entity<GovernanceRoleType>(ConfigureGovernanceRoleType);
             modelBuilder.Entity<GovernanceRoleType>().Metadata.SetIsTableExcludedFromMigrations(true);
+
+            modelBuilder.Entity<TrustGovernance>(ConfigureTrustGovernance);
+            modelBuilder.Entity<TrustGovernance>().Metadata.SetIsTableExcludedFromMigrations(true);
         }
 
         base.OnModelCreating(modelBuilder);
@@ -338,7 +345,6 @@ private static void ConfigureEducationEstablishmentGovernance(EntityTypeBuilder<
 
     }
 
-
     private static void ConfigureGovernanceRoleType(EntityTypeBuilder<GovernanceRoleType> governanceRoleTypeConfiguration)
     {
         governanceRoleTypeConfiguration.HasKey(e => e.SK);
@@ -351,4 +357,28 @@ private static void ConfigureGovernanceRoleType(EntityTypeBuilder<GovernanceRole
         governanceRoleTypeConfiguration.Property(e => e.ModifiedBy).HasColumnName("Modified By");
 
     }
+
+    private static void ConfigureTrustGovernance(EntityTypeBuilder<TrustGovernance> trustGovernanceConfiguration)
+    {
+        trustGovernanceConfiguration.HasKey(e => e.SK);
+        trustGovernanceConfiguration.ToTable("TrustGovernance", DEFAULT_SCHEMA);
+        trustGovernanceConfiguration.Property(e => e.SK).HasColumnName("SK");
+        trustGovernanceConfiguration.Property(e => e.TrustId).HasColumnName("FK_Trust");
+        trustGovernanceConfiguration.Property(e => e.GovernanceRoleTypeId).HasColumnName("FK_GovernanceRoleType");
+        trustGovernanceConfiguration.Property(e => e.GID)
+            .HasColumnName("GID")
+            .IsRequired()
+            .HasMaxLength(100);
+
+        trustGovernanceConfiguration.Property(e => e.Title).HasColumnName("Title");
+        trustGovernanceConfiguration.Property(e => e.Forename1).HasColumnName("Forename1");
+        trustGovernanceConfiguration.Property(e => e.Forename2).HasColumnName("Forename2");
+        trustGovernanceConfiguration.Property(e => e.Surname).HasColumnName("Surname");
+        trustGovernanceConfiguration.Property(e => e.Email).HasColumnName("Email").HasMaxLength(200);
+        trustGovernanceConfiguration.Property(e => e.DateOfAppointment).HasColumnName("Date of appointment");
+        trustGovernanceConfiguration.Property(e => e.DateTermOfOfficeEndsOrEnded).HasColumnName("Date term of office ends/ended");
+        trustGovernanceConfiguration.Property(e => e.AppointingBody).HasColumnName("Appointing body");
+        trustGovernanceConfiguration.Property(e => e.Modified).HasColumnName("Modified");
+        trustGovernanceConfiguration.Property(e => e.ModifiedBy).HasColumnName("Modified By");
+    }
 }

Dfe.Academies.Api.Infrastructure/QueryServices/EstablishmentQueryService.cs

@@ -1,5 +1,5 @@
 using Dfe.Academies.Application.Common.Interfaces;
-using Dfe.Academies.Infrastructure.Models;
+using Dfe.Academies.Application.Common.Models;
 using Microsoft.EntityFrameworkCore;
 
 namespace Dfe.Academies.Infrastructure.QueryServices

Dfe.Academies.Api.Infrastructure/QueryServices/TrustQueryService.cs

@@ -0,0 +1,35 @@
+using Dfe.Academies.Application.Common.Interfaces;
+using Dfe.Academies.Application.Common.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace Dfe.Academies.Infrastructure.QueryServices
+{
+    internal class TrustQueryService(MstrContext context) : ITrustQueryService
+    {
+        public IQueryable<TrustGovernanceQueryModel?>? GetTrustGovernanceByGroupIdOrUkprn(string? groupId, string? ukPrn)
+        {
+
+            // Check if the trust exists based on GroupID or UKPRN
+            var trustExists = context.Trusts.AsNoTracking().Any(t =>
+                (!string.IsNullOrEmpty(groupId) && t.GroupID == groupId) ||
+                (!string.IsNullOrEmpty(ukPrn) && t.UKPRN == ukPrn));
+
+            if (!trustExists)
+            {
+                return null;
+            }
+
+            var query = from t in context.Trusts.AsNoTracking()
+                join tg in context.TrustGovernances.AsNoTracking()
+                    on t.SK equals tg.TrustId
+                join grt in context.GovernanceRoleTypes.AsNoTracking()
+                    on tg.GovernanceRoleTypeId equals grt.SK
+                where (!string.IsNullOrEmpty(groupId) && t.GroupID == groupId) ||
+                      (!string.IsNullOrEmpty(ukPrn) && t.UKPRN == ukPrn)
+                select new TrustGovernanceQueryModel(t, grt, tg);
+
+            return query;
+        }
+    }
+
+}

Dfe.Academies.Api.Infrastructure/Repositories/EstablishmentRepository.cs

@@ -2,7 +2,6 @@
 using Dfe.Academies.Domain.Establishment;
 using Dfe.Academies.Domain.Interfaces.Repositories;
 using Microsoft.EntityFrameworkCore;
-using Dfe.Academies.Infrastructure.Models;
 
 namespace Dfe.Academies.Infrastructure.Repositories
 {

Dfe.Academies.Application/ApplicationServiceCollectionExtensions.cs

@@ -26,14 +26,20 @@ public static IServiceCollection AddApplicationDependencyGroup(
         public static IServiceCollection AddPersonsApiApplicationDependencyGroup(
             this IServiceCollection services, IConfiguration config)
         {
+            var performanceLoggingEnabled = config.GetValue<bool>("Features:PerformanceLoggingEnabled");
+
             services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
 
             services.AddMediatR(cfg =>
             {
                 cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly());
                 cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(UnhandledExceptionBehaviour<,>));
                 cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(ValidationBehaviour<,>));
-                cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(PerformanceBehaviour<,>));
+
+                if (performanceLoggingEnabled)
+                {
+                    cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(PerformanceBehaviour<,>));
+                }
             });
 
             return services;

Dfe.Academies.Application/Common/Interfaces/IEstablishmentQueryService.cs

@@ -1,4 +1,4 @@
-using Dfe.Academies.Infrastructure.Models;
+using Dfe.Academies.Application.Common.Models;
 
 namespace Dfe.Academies.Application.Common.Interfaces
 {

Dfe.Academies.Application/Common/Interfaces/ITrustQueryService.cs

@@ -0,0 +1,9 @@
+using Dfe.Academies.Application.Common.Models;
+
+namespace Dfe.Academies.Application.Common.Interfaces
+{
+    public interface ITrustQueryService
+    {
+        IQueryable<TrustGovernanceQueryModel?>? GetTrustGovernanceByGroupIdOrUkprn(string? groupId, string? ukPrn);
+    }
+}