Refactor create case and remove create methods from assets (#1299)

* Refactor create case and remove create methods from assets * Use correct service in cases controller * Fix tests
equinor · Oct 2, 2024 · a8e3288 · a8e3288
1 parent 4febb23
commit a8e3288
Show file tree

Hide file tree

Showing 41 changed files with 298 additions and 578 deletions.
diff --git a/backend/api/Controllers/CasesController.cs b/backend/api/Controllers/CasesController.cs
@@ -21,24 +21,27 @@ namespace api.Controllers;
 public class CasesController : ControllerBase
 {
     private readonly ICaseService _caseService;
+    private readonly ICreateCaseService _createCaseService;
     private readonly ICaseTimeSeriesService _caseTimeSeriesService;
     private readonly IDuplicateCaseService _duplicateCaseService;
 
     public CasesController(
         ICaseService caseService,
+        ICreateCaseService createCaseService,
         ICaseTimeSeriesService caseTimeSeriesService,
         IDuplicateCaseService duplicateCaseService
         )
     {
         _caseService = caseService;
+        _createCaseService = createCaseService;
         _caseTimeSeriesService = caseTimeSeriesService;
         _duplicateCaseService = duplicateCaseService;
     }
 
     [HttpPost]
     public async Task<ProjectWithAssetsDto> CreateCase([FromRoute] Guid projectId, [FromBody] CreateCaseDto caseDto)
     {
-        return await _caseService.CreateCase(projectId, caseDto);
+        return await _createCaseService.CreateCase(projectId, caseDto);
     }
 
     [HttpPost("copy", Name = "Duplicate")]

diff --git a/backend/api/Controllers/PROSPController.cs b/backend/api/Controllers/PROSPController.cs
@@ -78,17 +78,10 @@ public async Task<ActionResult<ProjectWithAssetsDto>> ImportFilesFromSharepointA
     {
         try
         {
-            var projectDto = await _prospSharepointImportService.ConvertSharepointFilesToProjectDto(projectId, dtos);
+            await _prospSharepointImportService.ConvertSharepointFilesToProjectDto(projectId, dtos);
+            var projectDto = await _projectService.GetProjectDto(projectId);
 
-            if (projectDto.Id == projectId)
-            {
-                return Ok(projectDto);
-            }
-            else
-            {
-                var fallbackDto = _projectService.GetProjectDto(projectId);
-                return Ok(fallbackDto);
-            }
+            return Ok(projectDto);
         }
         catch (ServiceException ex) when (ex.StatusCode == System.Net.HttpStatusCode.Forbidden)
         {

diff --git a/backend/api/Program.cs b/backend/api/Program.cs
@@ -172,6 +172,7 @@
 builder.Services.AddScoped<IProjectService, ProjectService>();
 builder.Services.AddScoped<IFusionService, FusionService>();
 builder.Services.AddScoped<ICaseService, CaseService>();
+builder.Services.AddScoped<ICreateCaseService, CreateCaseService>();
 builder.Services.AddScoped<IDrainageStrategyService, DrainageStrategyService>();
 builder.Services.AddScoped<IWellProjectService, WellProjectService>();
 builder.Services.AddScoped<IExplorationService, ExplorationService>();

diff --git a/backend/api/Repositories/Case/CaseRepository.cs b/backend/api/Repositories/Case/CaseRepository.cs
@@ -20,6 +20,14 @@ ILogger<CaseRepository> logger
         _logger = logger;
     }
 
+    public async Task<Case> AddCase(Case caseItem)
+    {
+        _context.Cases.Add(caseItem);
+        await _context.SaveChangesAsync();
+
+        return caseItem;
+    }
+
     public async Task<Case?> GetCase(Guid caseId)
     {
         return await Get<Case>(caseId);

diff --git a/backend/api/Repositories/Case/ICaseRepository.cs b/backend/api/Repositories/Case/ICaseRepository.cs
@@ -8,6 +8,7 @@ namespace api.Repositories;
 
 public interface ICaseRepository : IBaseRepository
 {
+    Task<Case> AddCase(Case caseItem);
     Task<Case?> GetCase(Guid caseId);
     Task<Case?> GetCaseWithIncludes(Guid caseId, params Expression<Func<Case, object>>[] includes);
     Case UpdateCase(Case updatedCase);

diff --git a/backend/api/Repositories/Substructure/ISubstructureRepository.cs b/backend/api/Repositories/Substructure/ISubstructureRepository.cs
@@ -1,10 +1,13 @@
+using System.Linq.Expressions;
+
 using api.Models;
 
 namespace api.Repositories;
 
 public interface ISubstructureRepository : IBaseRepository
 {
     Task<Substructure?> GetSubstructure(Guid substructureId);
+    Task<Substructure?> GetSubstructureWithIncludes(Guid substructureId, params Expression<Func<Substructure, object>>[] includes);
     Task<Substructure?> GetSubstructureWithCostProfile(Guid substructureId);
     Task<bool> SubstructureHasCostProfileOverride(Guid substructureId);
     Substructure UpdateSubstructure(Substructure substructure);

diff --git a/backend/api/Repositories/Substructure/SubstructureRepository.cs b/backend/api/Repositories/Substructure/SubstructureRepository.cs
@@ -1,3 +1,5 @@
+using System.Linq.Expressions;
+
 using api.Context;
 using api.Models;
 
@@ -18,6 +20,11 @@ public SubstructureRepository(DcdDbContext context) : base(context)
         return await Get<Substructure>(substructureId);
     }
 
+    public async Task<Substructure?> GetSubstructureWithIncludes(Guid substructureId, params Expression<Func<Substructure, object>>[] includes)
+    {
+        return await GetWithIncludes(substructureId, includes);
+    }
+
     public async Task<Substructure?> GetSubstructureWithCostProfile(Guid substructureId)
     {
         return await _context.Substructures

diff --git a/backend/api/Repositories/Surf/ISurfRepository.cs b/backend/api/Repositories/Surf/ISurfRepository.cs
@@ -1,9 +1,12 @@
+using System.Linq.Expressions;
+
 using api.Models;
 
 namespace api.Repositories;
 
 public interface ISurfRepository : IBaseRepository
 {
+    Task<Surf?> GetSurfWithIncludes(Guid surfId, params Expression<Func<Surf, object>>[] includes);
     Task<Surf?> GetSurf(Guid surfId);
     Task<Surf?> GetSurfWithCostProfile(Guid surfId);
     Task<bool> SurfHasCostProfileOverride(Guid topsideId);

diff --git a/backend/api/Repositories/Surf/SurfRepository.cs b/backend/api/Repositories/Surf/SurfRepository.cs
@@ -1,3 +1,5 @@
+using System.Linq.Expressions;
+
 using api.Context;
 using api.Models;
 
@@ -18,6 +20,11 @@ public SurfRepository(DcdDbContext context) : base(context)
         return await Get<Surf>(surfId);
     }
 
+    public async Task<Surf?> GetSurfWithIncludes(Guid surfId, params Expression<Func<Surf, object>>[] includes)
+    {
+        return await GetWithIncludes(surfId, includes);
+    }
+
     public async Task<Surf?> GetSurfWithCostProfile(Guid surfId)
     {
         return await _context.Surfs

diff --git a/backend/api/Repositories/Transport/ITransportRepository.cs b/backend/api/Repositories/Transport/ITransportRepository.cs
@@ -1,10 +1,13 @@
+using System.Linq.Expressions;
+
 using api.Models;
 
 namespace api.Repositories;
 
 public interface ITransportRepository : IBaseRepository
 {
     Task<Transport?> GetTransport(Guid transportId);
+    Task<Transport?> GetTransportWithIncludes(Guid transportId, params Expression<Func<Transport, object>>[] includes);
     Task<Transport?> GetTransportWithCostProfile(Guid transportId);
     Task<bool> TransportHasCostProfileOverride(Guid transportId);
     Transport UpdateTransport(Transport transport);

diff --git a/backend/api/Repositories/Transport/TransportRepository.cs b/backend/api/Repositories/Transport/TransportRepository.cs
@@ -1,3 +1,5 @@
+using System.Linq.Expressions;
+
 using api.Context;
 using api.Models;
 
@@ -18,6 +20,11 @@ public TransportRepository(DcdDbContext context) : base(context)
         return await Get<Transport>(transportId);
     }
 
+    public async Task<Transport?> GetTransportWithIncludes(Guid transportId, params Expression<Func<Transport, object>>[] includes)
+    {
+        return await GetWithIncludes(transportId, includes);
+    }
+
     public async Task<Transport?> GetTransportWithCostProfile(Guid transportId)
     {
         return await _context.Transports

diff --git a/backend/api/Repositories/WellProject/IWellProjectRepository.cs b/backend/api/Repositories/WellProject/IWellProjectRepository.cs
@@ -1,3 +1,5 @@
+using System.Linq.Expressions;
+
 using api.Enums;
 using api.Models;
 
@@ -6,6 +8,7 @@ namespace api.Repositories;
 public interface IWellProjectRepository : IBaseRepository
 {
     Task<WellProject?> GetWellProject(Guid wellProjectId);
+    Task<WellProject?> GetWellProjectWithIncludes(Guid wellProjectId, params Expression<Func<WellProject, object>>[] includes);
     Task<Well?> GetWell(Guid wellId);
     Task<bool> WellProjectHasProfile(Guid WellProjectId, WellProjectProfileNames profileType);
     WellProject UpdateWellProject(WellProject wellProject);

diff --git a/backend/api/Repositories/WellProject/WellProjectRepository.cs b/backend/api/Repositories/WellProject/WellProjectRepository.cs
@@ -21,6 +21,11 @@ public WellProjectRepository(DcdDbContext context) : base(context)
         return await Get<WellProject>(wellProjectId);
     }
 
+    public async Task<WellProject?> GetWellProjectWithIncludes(Guid wellProjectId, params Expression<Func<WellProject, object>>[] includes)
+    {
+        return await GetWithIncludes(wellProjectId, includes);
+    }
+
     public async Task<Well?> GetWell(Guid wellId)
     {
         return await Get<Well>(wellId);

diff --git a/backend/api/Services/Entities/Case/CaseService.cs b/backend/api/Services/Entities/Case/CaseService.cs
@@ -18,13 +18,6 @@ public class CaseService : ICaseService
     private readonly DcdDbContext _context;
     private readonly IProjectService _projectService;
     private readonly IProjectAccessService _projectAccessService;
-    private readonly IDrainageStrategyService _drainageStrategyService;
-    private readonly ITopsideService _topsideService;
-    private readonly ISurfService _surfService;
-    private readonly ISubstructureService _substructureService;
-    private readonly ITransportService _transportService;
-    private readonly IExplorationService _explorationService;
-    private readonly IWellProjectService _wellProjectService;
     private readonly ILogger<CaseService> _logger;
     private readonly IMapper _mapper;
     private readonly IMapperService _mapperService;
@@ -34,13 +27,6 @@ public CaseService(
         DcdDbContext context,
         IProjectService projectService,
         ILoggerFactory loggerFactory,
-        IDrainageStrategyService drainageStrategyService,
-        ITopsideService topsideService,
-        ISurfService surfService,
-        ISubstructureService substructureService,
-        ITransportService transportService,
-        IExplorationService explorationService,
-        IWellProjectService wellProjectService,
         ICaseRepository repository,
         IMapperService mapperService,
         IMapper mapper,
@@ -49,114 +35,13 @@ IProjectAccessService projectAccessService
     {
         _context = context;
         _projectService = projectService;
-        _drainageStrategyService = drainageStrategyService;
-        _topsideService = topsideService;
-        _surfService = surfService;
-        _substructureService = substructureService;
-        _transportService = transportService;
-        _explorationService = explorationService;
-        _wellProjectService = wellProjectService;
         _logger = loggerFactory.CreateLogger<CaseService>();
         _mapper = mapper;
         _mapperService = mapperService;
         _repository = repository;
         _projectAccessService = projectAccessService;
     }
 
-    public async Task<ProjectWithAssetsDto> CreateCase(Guid projectId, CreateCaseDto createCaseDto)
-    {
-        var caseItem = _mapper.Map<Case>(createCaseDto);
-        if (caseItem == null)
-        {
-            throw new ArgumentNullException(nameof(caseItem));
-        }
-        var project = await _projectService.GetProjectWithCasesAndAssets(projectId);
-        caseItem.Project = project;
-        caseItem.CapexFactorFeasibilityStudies = 0.015;
-        caseItem.CapexFactorFEEDStudies = 0.015;
-
-        if (caseItem.DG4Date == DateTimeOffset.MinValue)
-        {
-            caseItem.DG4Date = new DateTimeOffset(2030, 1, 1, 0, 0, 0, TimeSpan.Zero);
-        }
-
-        caseItem.CreateTime = DateTimeOffset.UtcNow;
-
-        var createdCase = _context.Cases!.Add(caseItem);
-        await _context.SaveChangesAsync();
-
-        var drainageStrategyDto = new CreateDrainageStrategyDto
-        {
-            Name = "Drainage strategy",
-            Description = ""
-        };
-        var drainageStrategy = await _drainageStrategyService.CreateDrainageStrategy(projectId, createdCase.Entity.Id, drainageStrategyDto);
-        caseItem.DrainageStrategyLink = drainageStrategy.Id;
-
-        var topsideDto = new CreateTopsideDto
-        {
-            Name = "Topside",
-            Source = Source.ConceptApp,
-        };
-        var topside = await _topsideService.CreateTopside(projectId, createdCase.Entity.Id, topsideDto);
-        caseItem.TopsideLink = topside.Id;
-
-        var surfDto = new CreateSurfDto
-        {
-            Name = "Surf",
-            Source = Source.ConceptApp,
-        };
-        var surf = await _surfService.CreateSurf(projectId, createdCase.Entity.Id, surfDto);
-        caseItem.SurfLink = surf.Id;
-
-        var substructureDto = new CreateSubstructureDto
-        {
-            Name = "Substructure",
-            Source = Source.ConceptApp,
-        };
-        var substructure = await _substructureService.CreateSubstructure(projectId, createdCase.Entity.Id, substructureDto);
-        caseItem.SubstructureLink = substructure.Id;
-
-        var transportDto = new CreateTransportDto
-        {
-            Name = "Transport",
-            Source = Source.ConceptApp,
-        };
-        var transport = await _transportService.CreateTransport(projectId, createdCase.Entity.Id, transportDto);
-        caseItem.TransportLink = transport.Id;
-
-        var explorationDto = new CreateExplorationDto
-        {
-            Name = "Exploration",
-        };
-        var exploration = await _explorationService.CreateExploration(projectId, createdCase.Entity.Id, explorationDto);
-        caseItem.ExplorationLink = exploration.Id;
-
-        var wellProjectDto = new CreateWellProjectDto
-        {
-            Name = "WellProject",
-        };
-        var wellProject = await _wellProjectService.CreateWellProject(projectId, createdCase.Entity.Id, wellProjectDto);
-        caseItem.WellProjectLink = wellProject.Id;
-
-        return await _projectService.GetProjectDto(project.Id);
-    }
-
-    // TODO: Delete this method
-    public async Task<ProjectWithAssetsDto> UpdateCaseAndProfiles<TDto>(Guid caseId, TDto updatedCaseDto)
-        where TDto : BaseUpdateCaseDto
-    {
-        var caseItem = await GetCase(caseId);
-
-        _mapper.Map(updatedCaseDto, caseItem);
-
-        _context.Cases!.Update(caseItem);
-        await _repository.UpdateModifyTime(caseId);
-        await _context.SaveChangesAsync();
-
-        return await _projectService.GetProjectDto(caseItem.ProjectId);
-    }
-
     public async Task<ProjectWithAssetsDto> DeleteCase(Guid projectId, Guid caseId)
     {
         // Need to verify that the project from the URL is the same as the project of the resource
@@ -208,25 +93,7 @@ public async Task<Case> GetCaseWithIncludes(Guid caseId, params Expression<Func<
     // TODO: Delete this method
     public async Task<IEnumerable<Case>> GetAll()
     {
-        return await _context.Cases
-                .Include(c => c.TotalFeasibilityAndConceptStudies)
-                .Include(c => c.TotalFeasibilityAndConceptStudiesOverride)
-                .Include(c => c.TotalFEEDStudies)
-                .Include(c => c.TotalFEEDStudiesOverride)
-                .Include(c => c.TotalOtherStudiesCostProfile)
-                .Include(c => c.HistoricCostCostProfile)
-                .Include(c => c.WellInterventionCostProfile)
-                .Include(c => c.WellInterventionCostProfileOverride)
-                .Include(c => c.OffshoreFacilitiesOperationsCostProfile)
-                .Include(c => c.OffshoreFacilitiesOperationsCostProfileOverride)
-                .Include(c => c.OnshoreRelatedOPEXCostProfile)
-                .Include(c => c.AdditionalOPEXCostProfile)
-                .Include(c => c.CessationWellsCost)
-                .Include(c => c.CessationWellsCostOverride)
-                .Include(c => c.CessationOffshoreFacilitiesCost)
-                .Include(c => c.CessationOffshoreFacilitiesCostOverride)
-                .Include(c => c.CessationOnshoreFacilitiesCostProfile)
-                .ToListAsync();
+        return await _context.Cases.ToListAsync();
     }
 
     public async Task<CaseDto> UpdateCase<TDto>(