FAM transfer

src/Core/Dfe.Complete.Application/Projects/Commands/CreateProject/CreateMatTransferProject.cs

@@ -0,0 +1,103 @@
+using Dfe.Complete.Domain.Entities;
+using Dfe.Complete.Domain.Enums;
+using Dfe.Complete.Domain.Interfaces.Repositories;
+using Dfe.Complete.Domain.ValueObjects;
+using Dfe.Complete.Infrastructure.Models;
+using Dfe.Complete.Utils;
+using MediatR;
+
+namespace Dfe.Complete.Application.Projects.Commands.CreateProject;
+
+public record CreateMatTransferProjectCommand(
+    Urn Urn,
+    string NewTrustName,
+    string NewTrustReferenceNumber,
+    Ukprn OutgoingTrustUkprn,
+    DateOnly SignificantDate,
+    bool IsSignificantDateProvisional,
+    bool IsDueTo2Ri,
+    bool IsDueToInedaquateOfstedRating,
+    bool IsDueToIssues,
+    bool HandingOverToRegionalCaseworkService,
+    bool OutGoingTrustWillClose,
+    DateOnly AdvisoryBoardDate,
+    string AdvisoryBoardConditions,
+    string EstablishmentSharepointLink,
+    string IncomingTrustSharepointLink,
+    string OutgoingTrustSharepointLink,
+    string HandoverComments,
+    string? UserAdId) : IRequest<ProjectId>;
+
+public class CreateMatTransferProjectCommandHandler(
+        ICompleteRepository<Project> projectRepository,
+        ICompleteRepository<TransferTasksData> transferTaskRepository,
+        ICompleteRepository<User> userRepository)
+        : IRequestHandler<CreateMatTransferProjectCommand, ProjectId>
+    {
+        public async Task<ProjectId> Handle(CreateMatTransferProjectCommand request, CancellationToken cancellationToken)
+        {
+            // The user Team should be moved as a Claim or Group to the Entra (MS AD)
+            var projectUser = await GetUserByAdId(request.UserAdId);
+
+            var projectUserTeam = projectUser.Team;
+            var projectUserId = projectUser?.Id;
+
+            var projectTeam = EnumExtensions.FromDescription<ProjectTeam>(projectUserTeam);
+            var region = EnumMapper.MapTeamToRegion(projectTeam);
+
+            var createdAt = DateTime.UtcNow;
+            var tasksDataId = Guid.NewGuid();
+            var projectId = new ProjectId(Guid.NewGuid());
+
+            var transferTask = new TransferTasksData(new TaskDataId(tasksDataId), createdAt, createdAt, request.IsDueToInedaquateOfstedRating, request.IsDueToIssues, request.OutGoingTrustWillClose);
+
+            ProjectTeam team;
+            DateTime? assignedAt = null;
+            UserId? projectUserAssignedToId = null;
+
+            if (request.HandingOverToRegionalCaseworkService)
+            {
+                team = ProjectTeam.RegionalCaseWorkerServices;
+            }
+            else
+            {
+                team = projectTeam;
+                assignedAt = DateTime.UtcNow;
+                projectUserAssignedToId = projectUserId;
+            }
+
+            var project = Project.CreateMatTransferProject(
+                    projectId,
+                    request.Urn,
+                    createdAt,
+                    updatedAt: createdAt,
+                    request.OutgoingTrustUkprn,
+                    TaskType.Transfer,
+                    ProjectType.Transfer,
+                    tasksDataId,
+                    region,
+                    team,
+                    projectUser?.Id,
+                    projectUserAssignedToId,
+                    assignedAt,
+                    request.EstablishmentSharepointLink,
+                    request.IncomingTrustSharepointLink,
+                    request.OutgoingTrustSharepointLink,
+                    request.AdvisoryBoardDate,
+                    request.AdvisoryBoardConditions,
+                    request.SignificantDate,
+                    request.IsSignificantDateProvisional,
+                    request.IsDueTo2Ri,
+                    request.NewTrustName,
+                    request.NewTrustReferenceNumber,
+                    request.HandoverComments);
+
+
+        await transferTaskRepository.AddAsync(transferTask, cancellationToken);
+        await projectRepository.AddAsync(project, cancellationToken);
+
+        return project.Id;
+    }
+
+        private async Task<User> GetUserByAdId(string? userAdId) => await userRepository.FindAsync(x => x.ActiveDirectoryUserId == userAdId);
+    }

src/Core/Dfe.Complete.Application/Projects/Queries/GetProject/GetProjectByTrn.cs

@@ -15,8 +15,11 @@ public class GetProjectByTrn(ICompleteRepository<Project> projectRepo) : IReques
     {
         try
         {
-            var result = await projectRepo.FindAsync(x => x.NewTrustReferenceNumber == request.NewTrustReferenceNumber, cancellationToken);
-            return Result<GetProjectByTrnResponseDto?>.Success(new GetProjectByTrnResponseDto(result.Id.Value, result.NewTrustName));
+            var project = await projectRepo.FindAsync(x => x.NewTrustReferenceNumber == request.NewTrustReferenceNumber, cancellationToken);
+
+            var result = project != null ? new GetProjectByTrnResponseDto(project.Id.Value, project.NewTrustName) : null;
+
+            return Result<GetProjectByTrnResponseDto?>.Success(result);
         }
         catch (Exception e)
         {

src/Core/Dfe.Complete.Domain/Entities/Project.cs

@@ -333,6 +333,54 @@ public static Project CreateMatConversionProject(
         return project;
     }
 
+        public static Project CreateMatTransferProject(
+        ProjectId Id,
+        Urn urn,
+        DateTime createdAt,
+        DateTime updatedAt,
+        Ukprn outgoingTrustUkprn,
+        TaskType taskType,
+        ProjectType projectType,
+        Guid tasksDataId,
+        Region? region,
+        ProjectTeam team,
+        UserId? regionalDeliveryOfficerId,
+        UserId? assignedToId,
+        DateTime? assignedAt,
+        string establishmentSharepointLink,
+        string incomingTrustSharepointLink,
+        string outgoingTrustSharepointLink,
+        DateOnly advisoryBoardDate,
+        string advisoryBoardConditions,
+        DateOnly significantDate,
+        bool isSignificantDateProvisional,
+        bool isDueTo2Ri,
+        string newTrustName,
+        string newTrustReferenceNumber,
+        string? handoverComments)
+        {
+            var project = new Project(Id, urn, createdAt, updatedAt, taskType, projectType, tasksDataId, significantDate,
+                isSignificantDateProvisional, null, outgoingTrustUkprn, region, isDueTo2Ri, null,
+                advisoryBoardDate, advisoryBoardConditions, establishmentSharepointLink, incomingTrustSharepointLink, outgoingTrustSharepointLink,
+                null, team, regionalDeliveryOfficerId, assignedToId, assignedAt, newTrustName, newTrustReferenceNumber);
+
+            if (!string.IsNullOrEmpty(handoverComments))
+            {
+                project.AddNote(new Note
+                {
+                    CreatedAt = project.CreatedAt,
+                    ProjectId = project.Id,
+                    Body = handoverComments,
+                    TaskIdentifier = "handover",
+                    UserId = assignedToId
+                });
+            }
+
+            project.AddDomainEvent(new ProjectCreatedEvent(project));
+
+            return project;
+        }
+
     private void AddNote(Note? note)
     {
         if (note != null)

src/Frontend/Dfe.Complete/Extensions/UserExtensions.cs

@@ -0,0 +1,14 @@
+using System.Security.Claims;
+
+namespace Dfe.Complete.Extensions
+{
+    public static class UserExtensions
+    {
+        public static string GetUserAdId(this ClaimsPrincipal value)
+        {
+            var userAdId = value.Claims.SingleOrDefault(c => c.Type.Contains("objectidentifier"))?.Value;
+
+            return userAdId;
+        }
+    }
+}

src/Frontend/Dfe.Complete/Pages/Projects/Conversion/CreateNewProject.cshtml.cs

@@ -7,6 +7,7 @@
 using MediatR;
 using Dfe.Complete.Domain.ValueObjects;
 using Microsoft.AspNetCore.Authorization;
+using Dfe.Complete.Extensions;
 
 namespace Dfe.Complete.Pages.Projects.Conversion
 {
@@ -86,8 +87,8 @@ public async Task<IActionResult> OnPost(CancellationToken cancellationToken)
                 return Page();
             }
 
-            var userAdId = User.Claims.SingleOrDefault(c => c.Type.Contains("objectidentifier"))?.Value;
-            
+            var userAdId = User.GetUserAdId();
+
             var createProjectCommand = new CreateConversionProjectCommand(
                 Urn: new Urn(int.Parse(URN)),
                 SignificantDate: ProvisionalConversionDate.HasValue ? DateOnly.FromDateTime(ProvisionalConversionDate.Value) : default,

src/Frontend/Dfe.Complete/Pages/Projects/CreateNewProject.cshtml.cs

@@ -21,6 +21,7 @@ public IActionResult OnPost()
                 "conversion" => "/Projects/Conversion/CreateNewProject",
                 "fam_conversion" => "/Projects/MatConversion/CreateNewProject",
                 "transfer" => "/Projects/Transfer/CreateNewProject",
+                "fam_transfer" => "/Projects/MatTransfer/CreateNewProject",
                 _ => string.Empty
             };
 

src/Frontend/Dfe.Complete/Pages/Projects/MatConversion/CreateNewProject.cshtml.cs

@@ -82,15 +82,13 @@ public void OnGet()
 
     public async Task<IActionResult> OnPost(CancellationToken cancellationToken)
     {
-        await CheckForExistingProjectWithTrust(cancellationToken);
-
         if (!ModelState.IsValid)
         {
             errorService.AddErrors(ModelState);
             return Page();
         }
 
-        var userAdId = User.Claims.SingleOrDefault(c => c.Type.Contains("objectidentifier"))?.Value;
+        var userAdId = User.GetUserAdId();
 
         var createProjectCommand = new CreateMatConversionProjectCommand(
             Urn: new Urn(int.Parse(URN)),
@@ -117,16 +115,4 @@ public async Task<IActionResult> OnPost(CancellationToken cancellationToken)
 
         return Redirect($"/projects/conversion-projects/{projectId}/created");
     }
-
-    private async Task CheckForExistingProjectWithTrust(CancellationToken cancellationToken)
-    {
-        var result = await sender.Send(new GetProjectByTrnQuery(TrustReferenceNumber), cancellationToken);
-        var existingProject = result.Value;
-
-        if (existingProject != null && !string.IsNullOrEmpty(existingProject.NewTrustName))
-        {
-            ModelState.AddModelError(nameof(TrustName),
-                $"A trust with this TRN already exists. It is called {existingProject.NewTrustName}. Check the trust name you have entered for this conversion/transfer");
-        }
-    }
 }