diff --git a/backend/api/Controllers/BlobStorageController.cs b/backend/api/Controllers/BlobStorageController.cs
index ed7b7d7e1..5dd6d6072 100644
--- a/backend/api/Controllers/BlobStorageController.cs
+++ b/backend/api/Controllers/BlobStorageController.cs
@@ -5,7 +5,7 @@
 
 [Authorize]
 [ApiController]
-[Route("projects/{projectId}/cases/{caseId}/images")]
+[Route("projects/{projectId}")]
 public class BlobStorageController : ControllerBase
 {
     private readonly IBlobStorageService _blobStorageService;
@@ -15,8 +15,7 @@ public BlobStorageController(IBlobStorageService blobStorageService)
         _blobStorageService = blobStorageService;
     }
 
-    [HttpPost]
-    public async Task<ActionResult<ImageDto>> UploadImage(Guid projectId, [FromForm] string projectName, Guid caseId, [FromForm] IFormFile image)
+    private async Task<ActionResult<ImageDto>> UploadImage(Guid projectId, string projectName, Guid? caseId, IFormFile image)
     {
         const int maxFileSize = 5 * 1024 * 1024; // 5MB
         string[] permittedExtensions = { ".jpg", ".jpeg", ".png", ".gif" };
@@ -37,12 +36,32 @@ public async Task<ActionResult<ImageDto>> UploadImage(Guid projectId, [FromForm]
             return BadRequest($"File {image.FileName} has an invalid extension. Only image files are allowed.");
         }
 
-        // Process the image upload
-        var imageDto = await _blobStorageService.SaveImage(projectId, projectName, image, caseId);
-        return Ok(imageDto);
+        try
+        {
+            if (caseId.HasValue)
+            {
+                var imageDto = await _blobStorageService.SaveImage(projectId, projectName, image, caseId.Value);
+                return Ok(imageDto);
+            }
+            else
+            {
+                var imageDto = await _blobStorageService.SaveImage(projectId, projectName, image);
+                return Ok(imageDto);
+            }
+        }
+        catch (Exception)
+        {
+            return StatusCode(StatusCodes.Status500InternalServerError, "An error occurred while uploading the image.");
+        }
+    }
+
+    [HttpPost("cases/{caseId}/images")]
+    public Task<ActionResult<ImageDto>> UploadCaseImage(Guid projectId, [FromForm] string projectName, Guid caseId, [FromForm] IFormFile image)
+    {
+        return UploadImage(projectId, projectName, caseId, image);
     }
 
-    [HttpGet]
+    [HttpGet("cases/{caseId}/images")]
     public async Task<ActionResult<List<ImageDto>>> GetImages(Guid projectId, Guid caseId)
     {
         try
@@ -56,12 +75,12 @@ public async Task<ActionResult<List<ImageDto>>> GetImages(Guid projectId, Guid c
         }
     }
 
-    [HttpDelete("{imageId}")]
-    public async Task<ActionResult> DeleteImage(Guid projectId, Guid caseId, Guid imageId)
+    [HttpDelete("cases/{caseId}/images/{imageId}")]
+    public async Task<ActionResult> DeleteCaseImage(Guid imageId)
     {
         try
         {
-            await _blobStorageService.DeleteImage(caseId, imageId);
+            await _blobStorageService.DeleteImage(imageId);
             return NoContent();
         }
         catch (Exception)
@@ -70,4 +89,37 @@ public async Task<ActionResult> DeleteImage(Guid projectId, Guid caseId, Guid im
         }
     }
 
+    [HttpPost("images")]
+    public Task<ActionResult<ImageDto>> UploadProjectImage(Guid projectId, [FromForm] string projectName, [FromForm] IFormFile image)
+    {
+        return UploadImage(projectId, projectName, null, image);
+    }
+
+    [HttpGet("images")]
+    public async Task<ActionResult<List<ImageDto>>> GetProjectImages(Guid projectId)
+    {
+        try
+        {
+            var imageDtos = await _blobStorageService.GetProjectImages(projectId);
+            return Ok(imageDtos);
+        }
+        catch (Exception)
+        {
+            return StatusCode(StatusCodes.Status500InternalServerError, "An error occurred while retrieving images.");
+        }
+    }
+
+    [HttpDelete("images/{imageId}")]
+    public async Task<ActionResult> DeleteProjectImage(Guid imageId)
+    {
+        try
+        {
+            await _blobStorageService.DeleteImage(imageId);
+            return NoContent();
+        }
+        catch (Exception)
+        {
+            return StatusCode(StatusCodes.Status500InternalServerError, "An error occurred while deleting the image.");
+        }
+    }
 }
diff --git a/backend/api/Dtos/Image/imageDto.cs b/backend/api/Dtos/Image/imageDto.cs
index 4e3e3c71a..c867c8fb6 100644
--- a/backend/api/Dtos/Image/imageDto.cs
+++ b/backend/api/Dtos/Image/imageDto.cs
@@ -18,7 +18,7 @@ public class ImageDto
     public string? Description { get; set; }
 
     [Required]
-    public Guid CaseId { get; set; }
+    public Guid? CaseId { get; set; }
 
     [Required]
     public string ProjectName { get; set; } = null!;
diff --git a/backend/api/Migrations/20240709120742_projectImageUpload.Designer.cs b/backend/api/Migrations/20240709120742_projectImageUpload.Designer.cs
new file mode 100644
index 000000000..e7d04342a
--- /dev/null
+++ b/backend/api/Migrations/20240709120742_projectImageUpload.Designer.cs
@@ -0,0 +1,3597 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using api.Context;
+
+#nullable disable
+
+namespace api.Migrations
+{
+    [DbContext(typeof(DcdDbContext))]
+    [Migration("20240709120742_projectImageUpload")]
+    partial class projectImageUpload
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("api.Models.AdditionalOPEXCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("AdditionalOPEXCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.AppraisalWellCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("Exploration.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Exploration.Id")
+                        .IsUnique();
+
+                    b.ToTable("AppraisalWellCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.Case", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("APXDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("APZDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("ArtificialLift")
+                        .HasColumnType("int");
+
+                    b.Property<double>("BreakEven")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CapexFactorFEEDStudies")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CapexFactorFeasibilityStudies")
+                        .HasColumnType("float");
+
+                    b.Property<DateTimeOffset>("CreateTime")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DG0Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DG1Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DG2Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DG3Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DG4Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DGADate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DGBDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DGCDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("DrainageStrategyLink")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("ExplorationLink")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("FacilitiesAvailability")
+                        .HasColumnType("float");
+
+                    b.Property<int>("GasInjectorCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Host")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("ModifyTime")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<double>("NPV")
+                        .HasColumnType("float");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProducerCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductionStrategyOverview")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<bool>("ReferenceCase")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SharepointFileId")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SharepointFileName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("SharepointFileUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("SubstructureLink")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("SurfLink")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("TopsideLink")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("TransportLink")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("WaterInjectorCount")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProjectLink")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Cases");
+                });
+
+            modelBuilder.Entity("api.Models.CessationOffshoreFacilitiesCost", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("CessationOffshoreFacilitiesCost");
+                });
+
+            modelBuilder.Entity("api.Models.CessationOffshoreFacilitiesCostOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("CessationOffshoreFacilitiesCostOverride");
+                });
+
+            modelBuilder.Entity("api.Models.CessationOnshoreFacilitiesCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("CessationOnshoreFacilitiesCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.CessationWellsCost", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("CessationWellsCost");
+                });
+
+            modelBuilder.Entity("api.Models.CessationWellsCostOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("CessationWellsCostOverride");
+                });
+
+            modelBuilder.Entity("api.Models.Co2Emissions", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("Co2Emissions");
+                });
+
+            modelBuilder.Entity("api.Models.Co2EmissionsOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("Co2EmissionsOverride");
+                });
+
+            modelBuilder.Entity("api.Models.CountryOfficeCost", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("Exploration.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Exploration.Id")
+                        .IsUnique();
+
+                    b.ToTable("CountryOfficeCost");
+                });
+
+            modelBuilder.Entity("api.Models.DeferredGasProduction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("DeferredGasProduction");
+                });
+
+            modelBuilder.Entity("api.Models.DeferredOilProduction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("DeferredOilProduction");
+                });
+
+            modelBuilder.Entity("api.Models.DevelopmentOperationalWellCosts", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("AnnualWellInterventionCostPerWell")
+                        .HasColumnType("float");
+
+                    b.Property<double>("PluggingAndAbandonment")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("RigMobDemob")
+                        .HasColumnType("float");
+
+                    b.Property<double>("RigUpgrading")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId")
+                        .IsUnique();
+
+                    b.ToTable("DevelopmentOperationalWellCosts");
+                });
+
+            modelBuilder.Entity("api.Models.DrainageStrategy", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("ArtificialLift")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("GasInjectorCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GasSolution")
+                        .HasColumnType("int");
+
+                    b.Property<double>("NGLYield")
+                        .HasColumnType("float");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProducerCount")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("WaterInjectorCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("DrainageStrategies");
+                });
+
+            modelBuilder.Entity("api.Models.DrillingSchedule", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DrillingSchedule");
+                });
+
+            modelBuilder.Entity("api.Models.Exploration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("RigMobDemob")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Explorations");
+                });
+
+            modelBuilder.Entity("api.Models.ExplorationOperationalWellCosts", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("AppraisalProjectDrillingCosts")
+                        .HasColumnType("float");
+
+                    b.Property<double>("AppraisalRigMobDemob")
+                        .HasColumnType("float");
+
+                    b.Property<double>("ExplorationProjectDrillingCosts")
+                        .HasColumnType("float");
+
+                    b.Property<double>("ExplorationRigMobDemob")
+                        .HasColumnType("float");
+
+                    b.Property<double>("ExplorationRigUpgrading")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId")
+                        .IsUnique();
+
+                    b.ToTable("ExplorationOperationalWellCosts");
+                });
+
+            modelBuilder.Entity("api.Models.ExplorationWell", b =>
+                {
+                    b.Property<Guid>("ExplorationId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("WellId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("DrillingScheduleId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("ExplorationId", "WellId");
+
+                    b.HasIndex("DrillingScheduleId");
+
+                    b.HasIndex("WellId");
+
+                    b.ToTable("ExplorationWell");
+                });
+
+            modelBuilder.Entity("api.Models.ExplorationWellCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("Exploration.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Exploration.Id")
+                        .IsUnique();
+
+                    b.ToTable("ExplorationWellCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.FuelFlaringAndLosses", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("FuelFlaringAndLosses");
+                });
+
+            modelBuilder.Entity("api.Models.FuelFlaringAndLossesOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("FuelFlaringAndLossesOverride");
+                });
+
+            modelBuilder.Entity("api.Models.GAndGAdminCost", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("Exploration.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Exploration.Id")
+                        .IsUnique();
+
+                    b.ToTable("GAndGAdminCost");
+                });
+
+            modelBuilder.Entity("api.Models.GAndGAdminCostOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("Exploration.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Exploration.Id")
+                        .IsUnique();
+
+                    b.ToTable("GAndGAdminCostOverride");
+                });
+
+            modelBuilder.Entity("api.Models.GasInjectorCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProject.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WellProject.Id")
+                        .IsUnique();
+
+                    b.ToTable("GasInjectorCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.GasInjectorCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProject.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WellProject.Id")
+                        .IsUnique();
+
+                    b.ToTable("GasInjectorCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.GasProducerCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProject.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WellProject.Id")
+                        .IsUnique();
+
+                    b.ToTable("GasProducerCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.GasProducerCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProject.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WellProject.Id")
+                        .IsUnique();
+
+                    b.ToTable("GasProducerCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.HistoricCostCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("HistoricCostCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.Image", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("CaseId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset>("CreateTime")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ProjectName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CaseId");
+
+                    b.ToTable("Images");
+                });
+
+            modelBuilder.Entity("api.Models.ImportedElectricity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("ImportedElectricity");
+                });
+
+            modelBuilder.Entity("api.Models.ImportedElectricityOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("ImportedElectricityOverride");
+                });
+
+            modelBuilder.Entity("api.Models.NetSalesGas", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("NetSalesGas");
+                });
+
+            modelBuilder.Entity("api.Models.NetSalesGasOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("NetSalesGasOverride");
+                });
+
+            modelBuilder.Entity("api.Models.OffshoreFacilitiesOperationsCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("OffshoreFacilitiesOperationsCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.OffshoreFacilitiesOperationsCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("OffshoreFacilitiesOperationsCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.OilProducerCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProject.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WellProject.Id")
+                        .IsUnique();
+
+                    b.ToTable("OilProducerCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.OilProducerCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProject.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WellProject.Id")
+                        .IsUnique();
+
+                    b.ToTable("OilProducerCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.OnshoreRelatedOPEXCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("OnshoreRelatedOPEXCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileGas", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("ProductionProfileGas");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileNGL", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("ProductionProfileNGL");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileOil", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("ProductionProfileOil");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileWater", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("ProductionProfileWater");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileWaterInjection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("DrainageStrategy.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DrainageStrategy.Id")
+                        .IsUnique();
+
+                    b.ToTable("ProductionProfileWaterInjection");
+                });
+
+            modelBuilder.Entity("api.Models.Project", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("AverageDevelopmentDrillingDays")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2EmissionFromFuelGas")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2EmissionsFromFlaredGas")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2RemovedFromGas")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2Vented")
+                        .HasColumnType("float");
+
+                    b.Property<int>("Classification")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(1);
+
+                    b.Property<Guid>("CommonLibraryId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("CommonLibraryName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Country")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreateDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<double>("DailyEmissionFromDrillingRig")
+                        .HasColumnType("float");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<double>("FlaredGasPerProducedVolume")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("FusionProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("PhysicalUnit")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectCategory")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProjectPhase")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("ReferenceCaseId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("SharepointSiteUrl")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Projects");
+                });
+
+            modelBuilder.Entity("api.Models.SeismicAcquisitionAndProcessing", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("Exploration.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Exploration.Id")
+                        .IsUnique();
+
+                    b.ToTable("SeismicAcquisitionAndProcessing");
+                });
+
+            modelBuilder.Entity("api.Models.SidetrackCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("Exploration.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Exploration.Id")
+                        .IsUnique();
+
+                    b.ToTable("SidetrackCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.Substructure", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ApprovedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Concept")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CostYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("DG3Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("DG4Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<double>("DryWeight")
+                        .HasColumnType("float");
+
+                    b.Property<DateTimeOffset?>("LastChangedDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("Maturity")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset?>("ProspVersion")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Substructures");
+                });
+
+            modelBuilder.Entity("api.Models.SubstructureCessationCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Substructure.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Substructure.Id")
+                        .IsUnique();
+
+                    b.ToTable("SubstructureCessationCostProfiles");
+                });
+
+            modelBuilder.Entity("api.Models.SubstructureCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Substructure.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Substructure.Id")
+                        .IsUnique();
+
+                    b.ToTable("SubstructureCostProfiles");
+                });
+
+            modelBuilder.Entity("api.Models.SubstructureCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Substructure.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Substructure.Id")
+                        .IsUnique();
+
+                    b.ToTable("SubstructureCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.Surf", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ApprovedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ArtificialLift")
+                        .HasColumnType("int");
+
+                    b.Property<double>("CessationCost")
+                        .HasColumnType("float");
+
+                    b.Property<int>("CostYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("DG3Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("DG4Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("GasInjectorCount")
+                        .HasColumnType("int");
+
+                    b.Property<double>("InfieldPipelineSystemLength")
+                        .HasColumnType("float");
+
+                    b.Property<DateTimeOffset?>("LastChangedDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("Maturity")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ProducerCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProductionFlowline")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset?>("ProspVersion")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("RiserCount")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateCount")
+                        .HasColumnType("int");
+
+                    b.Property<double>("UmbilicalSystemLength")
+                        .HasColumnType("float");
+
+                    b.Property<int>("WaterInjectorCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Surfs");
+                });
+
+            modelBuilder.Entity("api.Models.SurfCessationCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Surf.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Surf.Id")
+                        .IsUnique();
+
+                    b.ToTable("SurfCessationCostProfiles");
+                });
+
+            modelBuilder.Entity("api.Models.SurfCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Surf.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Surf.Id")
+                        .IsUnique();
+
+                    b.ToTable("SurfCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.SurfCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Surf.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Surf.Id")
+                        .IsUnique();
+
+                    b.ToTable("SurfCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.Topside", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ApprovedBy")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ArtificialLift")
+                        .HasColumnType("int");
+
+                    b.Property<double>("CO2OnMaxGasProfile")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2OnMaxOilProfile")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2OnMaxWaterInjectionProfile")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2ShareGasProfile")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2ShareOilProfile")
+                        .HasColumnType("float");
+
+                    b.Property<double>("CO2ShareWaterInjectionProfile")
+                        .HasColumnType("float");
+
+                    b.Property<int>("CostYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("DG3Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("DG4Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<double>("DryWeight")
+                        .HasColumnType("float");
+
+                    b.Property<double>("FacilityOpex")
+                        .HasColumnType("float");
+
+                    b.Property<double>("FlaredGas")
+                        .HasColumnType("float");
+
+                    b.Property<double>("FuelConsumption")
+                        .HasColumnType("float");
+
+                    b.Property<double>("GasCapacity")
+                        .HasColumnType("float");
+
+                    b.Property<int>("GasInjectorCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("LastChangedDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("Maturity")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<double>("OilCapacity")
+                        .HasColumnType("float");
+
+                    b.Property<double>("PeakElectricityImported")
+                        .HasColumnType("float");
+
+                    b.Property<int>("ProducerCount")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset?>("ProspVersion")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("int");
+
+                    b.Property<double>("WaterInjectionCapacity")
+                        .HasColumnType("float");
+
+                    b.Property<int>("WaterInjectorCount")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Topsides");
+                });
+
+            modelBuilder.Entity("api.Models.TopsideCessationCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Topside.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Topside.Id")
+                        .IsUnique();
+
+                    b.ToTable("TopsideCessationCostProfiles");
+                });
+
+            modelBuilder.Entity("api.Models.TopsideCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Topside.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Topside.Id")
+                        .IsUnique();
+
+                    b.ToTable("TopsideCostProfiles");
+                });
+
+            modelBuilder.Entity("api.Models.TopsideCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Topside.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Topside.Id")
+                        .IsUnique();
+
+                    b.ToTable("TopsideCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.TotalFEEDStudies", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("TotalFEEDStudies");
+                });
+
+            modelBuilder.Entity("api.Models.TotalFEEDStudiesOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("TotalFEEDStudiesOverride");
+                });
+
+            modelBuilder.Entity("api.Models.TotalFeasibilityAndConceptStudies", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("TotalFeasibilityAndConceptStudies");
+                });
+
+            modelBuilder.Entity("api.Models.TotalFeasibilityAndConceptStudiesOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("TotalFeasibilityAndConceptStudiesOverride");
+                });
+
+            modelBuilder.Entity("api.Models.TotalOtherStudiesCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("TotalOtherStudiesCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.Transport", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("CostYear")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset?>("DG3Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("DG4Date")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<double>("GasExportPipelineLength")
+                        .HasColumnType("float");
+
+                    b.Property<DateTimeOffset?>("LastChangedDate")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("Maturity")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<double>("OilExportPipelineLength")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTimeOffset?>("ProspVersion")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("Source")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Transports");
+                });
+
+            modelBuilder.Entity("api.Models.TransportCessationCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Transport.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Transport.Id")
+                        .IsUnique();
+
+                    b.ToTable("TransportCessationCostProfiles");
+                });
+
+            modelBuilder.Entity("api.Models.TransportCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Transport.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Transport.Id")
+                        .IsUnique();
+
+                    b.ToTable("TransportCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.TransportCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("Transport.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Transport.Id")
+                        .IsUnique();
+
+                    b.ToTable("TransportCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.WaterInjectorCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProject.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WellProject.Id")
+                        .IsUnique();
+
+                    b.ToTable("WaterInjectorCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.WaterInjectorCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("WellProject.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WellProject.Id")
+                        .IsUnique();
+
+                    b.ToTable("WaterInjectorCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.Well", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<double>("DrillingDays")
+                        .HasColumnType("float");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<double>("PlugingAndAbandonmentCost")
+                        .HasColumnType("float");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("WellCategory")
+                        .HasColumnType("int");
+
+                    b.Property<double>("WellCost")
+                        .HasColumnType("float");
+
+                    b.Property<double>("WellInterventionCost")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("Wells");
+                });
+
+            modelBuilder.Entity("api.Models.WellInterventionCostProfile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("WellInterventionCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.WellInterventionCostProfileOverride", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("Case.Id")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EPAVersion")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("InternalData")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<bool>("Override")
+                        .HasColumnType("bit");
+
+                    b.Property<int>("StartYear")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Case.Id")
+                        .IsUnique();
+
+                    b.ToTable("WellInterventionCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.WellProject", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<int>("ArtificialLift")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Currency")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid>("ProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("WellProjects");
+                });
+
+            modelBuilder.Entity("api.Models.WellProjectWell", b =>
+                {
+                    b.Property<Guid>("WellProjectId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid>("WellId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("DrillingScheduleId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.HasKey("WellProjectId", "WellId");
+
+                    b.HasIndex("DrillingScheduleId");
+
+                    b.HasIndex("WellId");
+
+                    b.ToTable("WellProjectWell");
+                });
+
+            modelBuilder.Entity("api.Models.AdditionalOPEXCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("AdditionalOPEXCostProfile")
+                        .HasForeignKey("api.Models.AdditionalOPEXCostProfile", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.AppraisalWellCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Exploration", "Exploration")
+                        .WithOne("AppraisalWellCostProfile")
+                        .HasForeignKey("api.Models.AppraisalWellCostProfile", "Exploration.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Exploration");
+                });
+
+            modelBuilder.Entity("api.Models.Case", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("Cases")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.CessationOffshoreFacilitiesCost", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("CessationOffshoreFacilitiesCost")
+                        .HasForeignKey("api.Models.CessationOffshoreFacilitiesCost", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.CessationOffshoreFacilitiesCostOverride", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("CessationOffshoreFacilitiesCostOverride")
+                        .HasForeignKey("api.Models.CessationOffshoreFacilitiesCostOverride", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.CessationOnshoreFacilitiesCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("CessationOnshoreFacilitiesCostProfile")
+                        .HasForeignKey("api.Models.CessationOnshoreFacilitiesCostProfile", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.CessationWellsCost", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("CessationWellsCost")
+                        .HasForeignKey("api.Models.CessationWellsCost", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.CessationWellsCostOverride", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("CessationWellsCostOverride")
+                        .HasForeignKey("api.Models.CessationWellsCostOverride", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.Co2Emissions", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("Co2Emissions")
+                        .HasForeignKey("api.Models.Co2Emissions", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.Co2EmissionsOverride", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("Co2EmissionsOverride")
+                        .HasForeignKey("api.Models.Co2EmissionsOverride", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.CountryOfficeCost", b =>
+                {
+                    b.HasOne("api.Models.Exploration", "Exploration")
+                        .WithOne("CountryOfficeCost")
+                        .HasForeignKey("api.Models.CountryOfficeCost", "Exploration.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Exploration");
+                });
+
+            modelBuilder.Entity("api.Models.DeferredGasProduction", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("DeferredGasProduction")
+                        .HasForeignKey("api.Models.DeferredGasProduction", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.DeferredOilProduction", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("DeferredOilProduction")
+                        .HasForeignKey("api.Models.DeferredOilProduction", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.DevelopmentOperationalWellCosts", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithOne("DevelopmentOperationalWellCosts")
+                        .HasForeignKey("api.Models.DevelopmentOperationalWellCosts", "ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.DrainageStrategy", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("DrainageStrategies")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.Exploration", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("Explorations")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.ExplorationOperationalWellCosts", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithOne("ExplorationOperationalWellCosts")
+                        .HasForeignKey("api.Models.ExplorationOperationalWellCosts", "ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.ExplorationWell", b =>
+                {
+                    b.HasOne("api.Models.DrillingSchedule", "DrillingSchedule")
+                        .WithMany()
+                        .HasForeignKey("DrillingScheduleId");
+
+                    b.HasOne("api.Models.Exploration", "Exploration")
+                        .WithMany("ExplorationWells")
+                        .HasForeignKey("ExplorationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("api.Models.Well", "Well")
+                        .WithMany("ExplorationWells")
+                        .HasForeignKey("WellId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("DrillingSchedule");
+
+                    b.Navigation("Exploration");
+
+                    b.Navigation("Well");
+                });
+
+            modelBuilder.Entity("api.Models.ExplorationWellCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Exploration", "Exploration")
+                        .WithOne("ExplorationWellCostProfile")
+                        .HasForeignKey("api.Models.ExplorationWellCostProfile", "Exploration.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Exploration");
+                });
+
+            modelBuilder.Entity("api.Models.FuelFlaringAndLosses", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("FuelFlaringAndLosses")
+                        .HasForeignKey("api.Models.FuelFlaringAndLosses", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.FuelFlaringAndLossesOverride", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("FuelFlaringAndLossesOverride")
+                        .HasForeignKey("api.Models.FuelFlaringAndLossesOverride", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.GAndGAdminCost", b =>
+                {
+                    b.HasOne("api.Models.Exploration", "Exploration")
+                        .WithOne("GAndGAdminCost")
+                        .HasForeignKey("api.Models.GAndGAdminCost", "Exploration.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Exploration");
+                });
+
+            modelBuilder.Entity("api.Models.GAndGAdminCostOverride", b =>
+                {
+                    b.HasOne("api.Models.Exploration", "Exploration")
+                        .WithOne("GAndGAdminCostOverride")
+                        .HasForeignKey("api.Models.GAndGAdminCostOverride", "Exploration.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Exploration");
+                });
+
+            modelBuilder.Entity("api.Models.GasInjectorCostProfile", b =>
+                {
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithOne("GasInjectorCostProfile")
+                        .HasForeignKey("api.Models.GasInjectorCostProfile", "WellProject.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.GasInjectorCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithOne("GasInjectorCostProfileOverride")
+                        .HasForeignKey("api.Models.GasInjectorCostProfileOverride", "WellProject.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.GasProducerCostProfile", b =>
+                {
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithOne("GasProducerCostProfile")
+                        .HasForeignKey("api.Models.GasProducerCostProfile", "WellProject.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.GasProducerCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithOne("GasProducerCostProfileOverride")
+                        .HasForeignKey("api.Models.GasProducerCostProfileOverride", "WellProject.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.HistoricCostCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("HistoricCostCostProfile")
+                        .HasForeignKey("api.Models.HistoricCostCostProfile", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.Image", b =>
+                {
+                    b.HasOne("api.Models.Case", null)
+                        .WithMany("Images")
+                        .HasForeignKey("CaseId");
+                });
+
+            modelBuilder.Entity("api.Models.ImportedElectricity", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("ImportedElectricity")
+                        .HasForeignKey("api.Models.ImportedElectricity", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.ImportedElectricityOverride", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("ImportedElectricityOverride")
+                        .HasForeignKey("api.Models.ImportedElectricityOverride", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.NetSalesGas", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("NetSalesGas")
+                        .HasForeignKey("api.Models.NetSalesGas", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.NetSalesGasOverride", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("NetSalesGasOverride")
+                        .HasForeignKey("api.Models.NetSalesGasOverride", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.OffshoreFacilitiesOperationsCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("OffshoreFacilitiesOperationsCostProfile")
+                        .HasForeignKey("api.Models.OffshoreFacilitiesOperationsCostProfile", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.OffshoreFacilitiesOperationsCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("OffshoreFacilitiesOperationsCostProfileOverride")
+                        .HasForeignKey("api.Models.OffshoreFacilitiesOperationsCostProfileOverride", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.OilProducerCostProfile", b =>
+                {
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithOne("OilProducerCostProfile")
+                        .HasForeignKey("api.Models.OilProducerCostProfile", "WellProject.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.OilProducerCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithOne("OilProducerCostProfileOverride")
+                        .HasForeignKey("api.Models.OilProducerCostProfileOverride", "WellProject.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.OnshoreRelatedOPEXCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("OnshoreRelatedOPEXCostProfile")
+                        .HasForeignKey("api.Models.OnshoreRelatedOPEXCostProfile", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileGas", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("ProductionProfileGas")
+                        .HasForeignKey("api.Models.ProductionProfileGas", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileNGL", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("ProductionProfileNGL")
+                        .HasForeignKey("api.Models.ProductionProfileNGL", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileOil", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("ProductionProfileOil")
+                        .HasForeignKey("api.Models.ProductionProfileOil", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileWater", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("ProductionProfileWater")
+                        .HasForeignKey("api.Models.ProductionProfileWater", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.ProductionProfileWaterInjection", b =>
+                {
+                    b.HasOne("api.Models.DrainageStrategy", "DrainageStrategy")
+                        .WithOne("ProductionProfileWaterInjection")
+                        .HasForeignKey("api.Models.ProductionProfileWaterInjection", "DrainageStrategy.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrainageStrategy");
+                });
+
+            modelBuilder.Entity("api.Models.SeismicAcquisitionAndProcessing", b =>
+                {
+                    b.HasOne("api.Models.Exploration", "Exploration")
+                        .WithOne("SeismicAcquisitionAndProcessing")
+                        .HasForeignKey("api.Models.SeismicAcquisitionAndProcessing", "Exploration.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Exploration");
+                });
+
+            modelBuilder.Entity("api.Models.SidetrackCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Exploration", "Exploration")
+                        .WithOne("SidetrackCostProfile")
+                        .HasForeignKey("api.Models.SidetrackCostProfile", "Exploration.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Exploration");
+                });
+
+            modelBuilder.Entity("api.Models.Substructure", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("Substructures")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.SubstructureCessationCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Substructure", "Substructure")
+                        .WithOne("CessationCostProfile")
+                        .HasForeignKey("api.Models.SubstructureCessationCostProfile", "Substructure.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Substructure");
+                });
+
+            modelBuilder.Entity("api.Models.SubstructureCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Substructure", "Substructure")
+                        .WithOne("CostProfile")
+                        .HasForeignKey("api.Models.SubstructureCostProfile", "Substructure.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Substructure");
+                });
+
+            modelBuilder.Entity("api.Models.SubstructureCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.Substructure", "Substructure")
+                        .WithOne("CostProfileOverride")
+                        .HasForeignKey("api.Models.SubstructureCostProfileOverride", "Substructure.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Substructure");
+                });
+
+            modelBuilder.Entity("api.Models.Surf", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("Surfs")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.SurfCessationCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Surf", "Surf")
+                        .WithOne("CessationCostProfile")
+                        .HasForeignKey("api.Models.SurfCessationCostProfile", "Surf.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Surf");
+                });
+
+            modelBuilder.Entity("api.Models.SurfCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Surf", "Surf")
+                        .WithOne("CostProfile")
+                        .HasForeignKey("api.Models.SurfCostProfile", "Surf.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Surf");
+                });
+
+            modelBuilder.Entity("api.Models.SurfCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.Surf", "Surf")
+                        .WithOne("CostProfileOverride")
+                        .HasForeignKey("api.Models.SurfCostProfileOverride", "Surf.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Surf");
+                });
+
+            modelBuilder.Entity("api.Models.Topside", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("Topsides")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.TopsideCessationCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Topside", "Topside")
+                        .WithOne("CessationCostProfile")
+                        .HasForeignKey("api.Models.TopsideCessationCostProfile", "Topside.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Topside");
+                });
+
+            modelBuilder.Entity("api.Models.TopsideCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Topside", "Topside")
+                        .WithOne("CostProfile")
+                        .HasForeignKey("api.Models.TopsideCostProfile", "Topside.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Topside");
+                });
+
+            modelBuilder.Entity("api.Models.TopsideCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.Topside", "Topside")
+                        .WithOne("CostProfileOverride")
+                        .HasForeignKey("api.Models.TopsideCostProfileOverride", "Topside.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Topside");
+                });
+
+            modelBuilder.Entity("api.Models.TotalFEEDStudies", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("TotalFEEDStudies")
+                        .HasForeignKey("api.Models.TotalFEEDStudies", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.TotalFEEDStudiesOverride", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("TotalFEEDStudiesOverride")
+                        .HasForeignKey("api.Models.TotalFEEDStudiesOverride", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.TotalFeasibilityAndConceptStudies", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("TotalFeasibilityAndConceptStudies")
+                        .HasForeignKey("api.Models.TotalFeasibilityAndConceptStudies", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.TotalFeasibilityAndConceptStudiesOverride", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("TotalFeasibilityAndConceptStudiesOverride")
+                        .HasForeignKey("api.Models.TotalFeasibilityAndConceptStudiesOverride", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.TotalOtherStudiesCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("TotalOtherStudiesCostProfile")
+                        .HasForeignKey("api.Models.TotalOtherStudiesCostProfile", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.Transport", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("Transports")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.TransportCessationCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Transport", "Transport")
+                        .WithOne("CessationCostProfile")
+                        .HasForeignKey("api.Models.TransportCessationCostProfile", "Transport.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Transport");
+                });
+
+            modelBuilder.Entity("api.Models.TransportCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Transport", "Transport")
+                        .WithOne("CostProfile")
+                        .HasForeignKey("api.Models.TransportCostProfile", "Transport.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Transport");
+                });
+
+            modelBuilder.Entity("api.Models.TransportCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.Transport", "Transport")
+                        .WithOne("CostProfileOverride")
+                        .HasForeignKey("api.Models.TransportCostProfileOverride", "Transport.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Transport");
+                });
+
+            modelBuilder.Entity("api.Models.WaterInjectorCostProfile", b =>
+                {
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithOne("WaterInjectorCostProfile")
+                        .HasForeignKey("api.Models.WaterInjectorCostProfile", "WellProject.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.WaterInjectorCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithOne("WaterInjectorCostProfileOverride")
+                        .HasForeignKey("api.Models.WaterInjectorCostProfileOverride", "WellProject.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.Well", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("Wells")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.WellInterventionCostProfile", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("WellInterventionCostProfile")
+                        .HasForeignKey("api.Models.WellInterventionCostProfile", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.WellInterventionCostProfileOverride", b =>
+                {
+                    b.HasOne("api.Models.Case", "Case")
+                        .WithOne("WellInterventionCostProfileOverride")
+                        .HasForeignKey("api.Models.WellInterventionCostProfileOverride", "Case.Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Case");
+                });
+
+            modelBuilder.Entity("api.Models.WellProject", b =>
+                {
+                    b.HasOne("api.Models.Project", "Project")
+                        .WithMany("WellProjects")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Project");
+                });
+
+            modelBuilder.Entity("api.Models.WellProjectWell", b =>
+                {
+                    b.HasOne("api.Models.DrillingSchedule", "DrillingSchedule")
+                        .WithMany()
+                        .HasForeignKey("DrillingScheduleId");
+
+                    b.HasOne("api.Models.Well", "Well")
+                        .WithMany("WellProjectWells")
+                        .HasForeignKey("WellId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("api.Models.WellProject", "WellProject")
+                        .WithMany("WellProjectWells")
+                        .HasForeignKey("WellProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DrillingSchedule");
+
+                    b.Navigation("Well");
+
+                    b.Navigation("WellProject");
+                });
+
+            modelBuilder.Entity("api.Models.Case", b =>
+                {
+                    b.Navigation("AdditionalOPEXCostProfile");
+
+                    b.Navigation("CessationOffshoreFacilitiesCost");
+
+                    b.Navigation("CessationOffshoreFacilitiesCostOverride");
+
+                    b.Navigation("CessationOnshoreFacilitiesCostProfile");
+
+                    b.Navigation("CessationWellsCost");
+
+                    b.Navigation("CessationWellsCostOverride");
+
+                    b.Navigation("HistoricCostCostProfile");
+
+                    b.Navigation("Images");
+
+                    b.Navigation("OffshoreFacilitiesOperationsCostProfile");
+
+                    b.Navigation("OffshoreFacilitiesOperationsCostProfileOverride");
+
+                    b.Navigation("OnshoreRelatedOPEXCostProfile");
+
+                    b.Navigation("TotalFEEDStudies");
+
+                    b.Navigation("TotalFEEDStudiesOverride");
+
+                    b.Navigation("TotalFeasibilityAndConceptStudies");
+
+                    b.Navigation("TotalFeasibilityAndConceptStudiesOverride");
+
+                    b.Navigation("TotalOtherStudiesCostProfile");
+
+                    b.Navigation("WellInterventionCostProfile");
+
+                    b.Navigation("WellInterventionCostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.DrainageStrategy", b =>
+                {
+                    b.Navigation("Co2Emissions");
+
+                    b.Navigation("Co2EmissionsOverride");
+
+                    b.Navigation("DeferredGasProduction");
+
+                    b.Navigation("DeferredOilProduction");
+
+                    b.Navigation("FuelFlaringAndLosses");
+
+                    b.Navigation("FuelFlaringAndLossesOverride");
+
+                    b.Navigation("ImportedElectricity");
+
+                    b.Navigation("ImportedElectricityOverride");
+
+                    b.Navigation("NetSalesGas");
+
+                    b.Navigation("NetSalesGasOverride");
+
+                    b.Navigation("ProductionProfileGas");
+
+                    b.Navigation("ProductionProfileNGL");
+
+                    b.Navigation("ProductionProfileOil");
+
+                    b.Navigation("ProductionProfileWater");
+
+                    b.Navigation("ProductionProfileWaterInjection");
+                });
+
+            modelBuilder.Entity("api.Models.Exploration", b =>
+                {
+                    b.Navigation("AppraisalWellCostProfile");
+
+                    b.Navigation("CountryOfficeCost");
+
+                    b.Navigation("ExplorationWellCostProfile");
+
+                    b.Navigation("ExplorationWells");
+
+                    b.Navigation("GAndGAdminCost");
+
+                    b.Navigation("GAndGAdminCostOverride");
+
+                    b.Navigation("SeismicAcquisitionAndProcessing");
+
+                    b.Navigation("SidetrackCostProfile");
+                });
+
+            modelBuilder.Entity("api.Models.Project", b =>
+                {
+                    b.Navigation("Cases");
+
+                    b.Navigation("DevelopmentOperationalWellCosts");
+
+                    b.Navigation("DrainageStrategies");
+
+                    b.Navigation("ExplorationOperationalWellCosts");
+
+                    b.Navigation("Explorations");
+
+                    b.Navigation("Substructures");
+
+                    b.Navigation("Surfs");
+
+                    b.Navigation("Topsides");
+
+                    b.Navigation("Transports");
+
+                    b.Navigation("WellProjects");
+
+                    b.Navigation("Wells");
+                });
+
+            modelBuilder.Entity("api.Models.Substructure", b =>
+                {
+                    b.Navigation("CessationCostProfile");
+
+                    b.Navigation("CostProfile");
+
+                    b.Navigation("CostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.Surf", b =>
+                {
+                    b.Navigation("CessationCostProfile");
+
+                    b.Navigation("CostProfile");
+
+                    b.Navigation("CostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.Topside", b =>
+                {
+                    b.Navigation("CessationCostProfile");
+
+                    b.Navigation("CostProfile");
+
+                    b.Navigation("CostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.Transport", b =>
+                {
+                    b.Navigation("CessationCostProfile");
+
+                    b.Navigation("CostProfile");
+
+                    b.Navigation("CostProfileOverride");
+                });
+
+            modelBuilder.Entity("api.Models.Well", b =>
+                {
+                    b.Navigation("ExplorationWells");
+
+                    b.Navigation("WellProjectWells");
+                });
+
+            modelBuilder.Entity("api.Models.WellProject", b =>
+                {
+                    b.Navigation("GasInjectorCostProfile");
+
+                    b.Navigation("GasInjectorCostProfileOverride");
+
+                    b.Navigation("GasProducerCostProfile");
+
+                    b.Navigation("GasProducerCostProfileOverride");
+
+                    b.Navigation("OilProducerCostProfile");
+
+                    b.Navigation("OilProducerCostProfileOverride");
+
+                    b.Navigation("WaterInjectorCostProfile");
+
+                    b.Navigation("WaterInjectorCostProfileOverride");
+
+                    b.Navigation("WellProjectWells");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/backend/api/Migrations/20240709120742_projectImageUpload.cs b/backend/api/Migrations/20240709120742_projectImageUpload.cs
new file mode 100644
index 000000000..44a5fb424
--- /dev/null
+++ b/backend/api/Migrations/20240709120742_projectImageUpload.cs
@@ -0,0 +1,60 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace api.Migrations
+{
+    /// <inheritdoc />
+    public partial class projectImageUpload : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Images_Cases_CaseId",
+                table: "Images");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "CaseId",
+                table: "Images",
+                type: "uniqueidentifier",
+                nullable: true,
+                oldClrType: typeof(Guid),
+                oldType: "uniqueidentifier");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Images_Cases_CaseId",
+                table: "Images",
+                column: "CaseId",
+                principalTable: "Cases",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_Images_Cases_CaseId",
+                table: "Images");
+
+            migrationBuilder.AlterColumn<Guid>(
+                name: "CaseId",
+                table: "Images",
+                type: "uniqueidentifier",
+                nullable: false,
+                defaultValue: new Guid("00000000-0000-0000-0000-000000000000"),
+                oldClrType: typeof(Guid),
+                oldType: "uniqueidentifier",
+                oldNullable: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_Images_Cases_CaseId",
+                table: "Images",
+                column: "CaseId",
+                principalTable: "Cases",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
diff --git a/backend/api/Migrations/DcdDbContextModelSnapshot.cs b/backend/api/Migrations/DcdDbContextModelSnapshot.cs
index 0e2f970e7..5ab3da782 100644
--- a/backend/api/Migrations/DcdDbContextModelSnapshot.cs
+++ b/backend/api/Migrations/DcdDbContextModelSnapshot.cs
@@ -988,7 +988,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .ValueGeneratedOnAdd()
                         .HasColumnType("uniqueidentifier");
 
-                    b.Property<Guid>("CaseId")
+                    b.Property<Guid?>("CaseId")
                         .HasColumnType("uniqueidentifier");
 
                     b.Property<DateTimeOffset>("CreateTime")
@@ -2908,9 +2908,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                 {
                     b.HasOne("api.Models.Case", null)
                         .WithMany("Images")
-                        .HasForeignKey("CaseId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
+                        .HasForeignKey("CaseId");
                 });
 
             modelBuilder.Entity("api.Models.ImportedElectricity", b =>
diff --git a/backend/api/Models/Image.cs b/backend/api/Models/Image.cs
index e07a18e15..17efaded7 100644
--- a/backend/api/Models/Image.cs
+++ b/backend/api/Models/Image.cs
@@ -16,7 +16,7 @@ public class Image
     public string? Description { get; set; }
 
     [ForeignKey("Case")]
-    public Guid CaseId { get; set; }
+    public Guid? CaseId { get; set; }
 
     [Required]
     public string ProjectName { get; set; } = null!;
diff --git a/backend/api/Repositories/IImageRepository.cs b/backend/api/Repositories/IImageRepository.cs
index 96ce94df9..7dc8618b9 100644
--- a/backend/api/Repositories/IImageRepository.cs
+++ b/backend/api/Repositories/IImageRepository.cs
@@ -1,12 +1,10 @@
-using api.Dtos;
 using api.Models;
 
 public interface IImageRepository
 {
     Task AddImage(Image image);
     Task<List<Image>> GetImagesByCaseId(Guid caseId);
+    Task<List<Image>> GetImagesByProjectId(Guid projectId);
     Task DeleteImage(Image image);
-
     Task<Image?> GetImageById(Guid imageId);
-
 }
diff --git a/backend/api/Repositories/ImageRepository.cs b/backend/api/Repositories/ImageRepository.cs
index 87f5d046a..5f053da50 100644
--- a/backend/api/Repositories/ImageRepository.cs
+++ b/backend/api/Repositories/ImageRepository.cs
@@ -20,10 +20,16 @@ public async Task AddImage(Image image)
 
     public async Task<List<Image>> GetImagesByCaseId(Guid caseId)
     {
-        var images = await _context.Images
+        return await _context.Images
             .Where(img => img.CaseId == caseId)
             .ToListAsync();
-        return images;
+    }
+
+    public async Task<List<Image>> GetImagesByProjectId(Guid projectId)
+    {
+        return await _context.Images
+            .Where(img => img.ProjectId == projectId && img.CaseId == null)
+            .ToListAsync();
     }
 
     public async Task DeleteImage(Image image)
diff --git a/backend/api/Services/BlobStorageService.cs b/backend/api/Services/BlobStorageService.cs
index aea05dcdf..20deed21d 100644
--- a/backend/api/Services/BlobStorageService.cs
+++ b/backend/api/Services/BlobStorageService.cs
@@ -7,6 +7,7 @@
 using Azure.Storage.Blobs;
 using Azure.Storage.Blobs.Models;
 
+
 public class BlobStorageService : IBlobStorageService
 {
     private readonly BlobServiceClient _blobServiceClient;
@@ -20,13 +21,11 @@ public BlobStorageService(BlobServiceClient blobServiceClient, IImageRepository
         _imageRepository = imageRepository;
         _mapper = mapper;
         _containerName = GetContainerName(configuration);
-
     }
+
     private string GetContainerName(IConfiguration configuration)
     {
-
         var environment = Environment.GetEnvironmentVariable("AppConfiguration__Environment") ?? "default";
-
         var containerKey = environment switch
         {
             "localdev" => "AzureStorageAccountImageContainerCI",
@@ -43,19 +42,29 @@ private string GetContainerName(IConfiguration configuration)
         return configuration[containerKey]
                              ?? throw new InvalidOperationException($"Container name configuration for {environment} is missing.");
     }
+
     private string SanitizeBlobName(string name)
     {
         return name.Replace(" ", "-").Replace("/", "-").Replace("\\", "-");
     }
-    public async Task<ImageDto> SaveImage(Guid projectId, string projectName, IFormFile image, Guid caseId)
+
+    public async Task<ImageDto> SaveImage(Guid projectId, string projectName, IFormFile image, Guid? caseId = null)
     {
         var sanitizedProjectName = SanitizeBlobName(projectName);
         var containerClient = _blobServiceClient.GetBlobContainerClient(_containerName);
 
         var imageId = Guid.NewGuid();
-        var blobName = $"{sanitizedProjectName}/{caseId}/{imageId}";
-        var blobClient = containerClient.GetBlobClient(blobName);
 
+        if (projectId == Guid.Empty || caseId == Guid.Empty)
+        {
+            throw new ArgumentException("ProjectId and/or CaseId cannot be empty.");
+        }
+
+        var blobName = caseId.HasValue
+            ? $"{sanitizedProjectName}/cases/{caseId}/{imageId}"
+            : $"{sanitizedProjectName}/projects/{projectId}/{imageId}";
+
+        var blobClient = containerClient.GetBlobClient(blobName);
 
         await using var stream = image.OpenReadStream();
         await blobClient.UploadAsync(stream, new BlobHttpHeaders { ContentType = image.ContentType });
@@ -71,7 +80,6 @@ public async Task<ImageDto> SaveImage(Guid projectId, string projectName, IFormF
             CaseId = caseId,
             ProjectId = projectId,
             ProjectName = sanitizedProjectName
-
         };
 
         await _imageRepository.AddImage(imageEntity);
@@ -99,7 +107,20 @@ public async Task<List<ImageDto>> GetCaseImages(Guid caseId)
         return imageDtos;
     }
 
-    public async Task DeleteImage(Guid caseId, Guid imageId)
+    public async Task<List<ImageDto>> GetProjectImages(Guid projectId)
+    {
+        var images = await _imageRepository.GetImagesByProjectId(projectId);
+
+        var imageDtos = _mapper.Map<List<ImageDto>>(images);
+
+        if (imageDtos == null)
+        {
+            throw new InvalidOperationException("Image mapping failed.");
+        }
+        return imageDtos;
+    }
+
+    public async Task DeleteImage(Guid imageId)
     {
         var image = await _imageRepository.GetImageById(imageId);
         if (image == null)
@@ -110,12 +131,13 @@ public async Task DeleteImage(Guid caseId, Guid imageId)
         var containerClient = _blobServiceClient.GetBlobContainerClient(_containerName);
 
         var sanitizedProjectName = SanitizeBlobName(image.ProjectName);
-        var blobName = $"{sanitizedProjectName}/{image.CaseId}/{image.Id}";
+        var blobName = image.CaseId.HasValue
+            ? $"{sanitizedProjectName}/cases/{image.CaseId}/{image.Id}"
+            : $"{sanitizedProjectName}/projects/{image.ProjectId}/{image.Id}";
 
         var blobClient = containerClient.GetBlobClient(blobName);
 
         await blobClient.DeleteIfExistsAsync();
         await _imageRepository.DeleteImage(image);
     }
-
 }
diff --git a/backend/api/Services/IBlobStorageService.cs b/backend/api/Services/IBlobStorageService.cs
index ac84b31b3..ec20573d4 100644
--- a/backend/api/Services/IBlobStorageService.cs
+++ b/backend/api/Services/IBlobStorageService.cs
@@ -2,8 +2,8 @@
 
 public interface IBlobStorageService
 {
-    Task<ImageDto> SaveImage(Guid projectId, string projectName, IFormFile image, Guid caseId);
+    Task<ImageDto> SaveImage(Guid projectId, string projectName, IFormFile image, Guid? caseId = null);
     Task<List<ImageDto>> GetCaseImages(Guid caseId);
-    Task DeleteImage(Guid caseId, Guid imageId);
-
+    Task<List<ImageDto>> GetProjectImages(Guid projectId);
+    Task DeleteImage(Guid imageId);
 }
diff --git a/frontend/src/Components/Case/Components/CaseTabTable.tsx b/frontend/src/Components/Case/Components/CaseTabTable.tsx
index dde07c78a..7d6d8f645 100644
--- a/frontend/src/Components/Case/Components/CaseTabTable.tsx
+++ b/frontend/src/Components/Case/Components/CaseTabTable.tsx
@@ -60,6 +60,13 @@ const CaseTabTable = ({
     const [overrideModalProfileName, setOverrideModalProfileName] = useState<ProfileNames>()
     const [overrideModalProfileSet, setOverrideModalProfileSet] = useState<Dispatch<SetStateAction<any | undefined>>>()
     const [overrideProfile, setOverrideProfile] = useState<any>()
+    const [stagedEdit, setStagedEdit] = useState<any>()
+
+    useEffect(() => {
+        if (stagedEdit) {
+            addEdit(stagedEdit)
+        }
+    }, [stagedEdit])
 
     const profilesToRowData = () => {
         const tableRows: any[] = []
@@ -250,7 +257,7 @@ const CaseTabTable = ({
                 return result
             }
 
-            addEdit({
+            setStagedEdit({
                 newValue: p.newValue,
                 previousValue: p.oldValue,
                 inputLabel: p.data.profileName,
diff --git a/frontend/src/Components/Case/OverviewCasesTable/CasesDropMenu.tsx b/frontend/src/Components/Case/OverviewCasesTable/CasesDropMenu.tsx
index 3864acbcc..ebc22019d 100644
--- a/frontend/src/Components/Case/OverviewCasesTable/CasesDropMenu.tsx
+++ b/frontend/src/Components/Case/OverviewCasesTable/CasesDropMenu.tsx
@@ -62,7 +62,7 @@ const CasesDropMenu = ({
                 isOpen={confirmDelete}
                 size="sm"
                 content={[
-                    <Typography variant="body_short">
+                    <Typography key="modal-content" variant="body_short">
                         Are you sure you want to delete this case?
                     </Typography>,
                 ]}
@@ -73,6 +73,7 @@ const CasesDropMenu = ({
                     </div>
                 )}
             />
+
             <Menu
                 id="menu-complex"
                 open={isMenuOpen}
diff --git a/frontend/src/Components/Case/Tabs/Co2Emissions/CaseCO2Tab.tsx b/frontend/src/Components/Case/Tabs/Co2Emissions/CaseCO2Tab.tsx
index 01da25fc1..5e275e495 100644
--- a/frontend/src/Components/Case/Tabs/Co2Emissions/CaseCO2Tab.tsx
+++ b/frontend/src/Components/Case/Tabs/Co2Emissions/CaseCO2Tab.tsx
@@ -124,7 +124,7 @@ const CaseCO2Tab = () => {
                 editable: true,
                 overrideProfile: co2EmissionsOverrideData,
                 resourceName: "co2EmissionsOverride",
-                resourceId: drainageStrategyData.id,
+                resourceId: drainageStrategyData?.id,
                 resourceProfileId: co2EmissionsOverrideData?.id,
                 resourcePropertyKey: "co2EmissionsOverride",
             },
@@ -136,7 +136,7 @@ const CaseCO2Tab = () => {
                 overridable: false,
                 editable: false,
                 resourceName: "co2Intensity",
-                resourceId: drainageStrategyData.id,
+                resourceId: drainageStrategyData?.id,
                 resourceProfileId: co2Intensity?.id,
                 resourcePropertyKey: "co2Intensity",
             },
diff --git a/frontend/src/Components/Controls/UndoControls.tsx b/frontend/src/Components/Controls/UndoControls.tsx
index ed5b9ba4b..0950a8512 100644
--- a/frontend/src/Components/Controls/UndoControls.tsx
+++ b/frontend/src/Components/Controls/UndoControls.tsx
@@ -4,7 +4,7 @@ import {
 } from "@equinor/eds-core-react"
 import { check_circle_outlined, undo, redo } from "@equinor/eds-icons"
 import styled from "styled-components"
-import { useIsMutating } from "react-query"
+import { useIsFetching } from "react-query"
 import { useParams } from "react-router-dom"
 import useDataEdits from "../../Hooks/useDataEdits"
 import { useCaseContext } from "../../Context/CaseContext"
@@ -30,14 +30,14 @@ const UndoControls: React.FC = () => {
     } = useCaseContext()
     const { caseId } = useParams()
 
-    const isMutating = useIsMutating()
+    const isFetching = useIsFetching()
 
     const { undoEdit, redoEdit } = useDataEdits()
 
     const currentEditId = getCurrentEditId(editIndexes, caseId)
 
     const canUndo = () => {
-        if (isMutating) {
+        if (isFetching) {
             return false
         }
         if (!currentEditId || !caseEditsBelongingToCurrentCase) {
@@ -49,7 +49,7 @@ const UndoControls: React.FC = () => {
     }
 
     const canRedo = () => {
-        if (isMutating) {
+        if (isFetching) {
             return false
         }
 
@@ -74,10 +74,10 @@ const UndoControls: React.FC = () => {
     }
 
     useEffect(() => {
-        if (isMutating) {
+        if (isFetching) {
             startCountDown()
         }
-    }, [isMutating])
+    }, [isFetching])
 
     useEffect(() => {
         const handleKeyDown = (event: KeyboardEvent) => {
@@ -126,7 +126,8 @@ const UndoControls: React.FC = () => {
                         </Tooltip>
                     )
             }
-            {/* comment out for qa release
+            {/* comment out for qa release */}
+
             <Tooltip title={canUndo() ? "Undo" : "No changes to undo"}>
                 <Button
                     variant="ghost_icon"
diff --git a/frontend/src/Components/EditTechnicalInput/PROSPCaseList.tsx b/frontend/src/Components/EditTechnicalInput/PROSPCaseList.tsx
index 8f570e6ac..6c1f7862f 100644
--- a/frontend/src/Components/EditTechnicalInput/PROSPCaseList.tsx
+++ b/frontend/src/Components/EditTechnicalInput/PROSPCaseList.tsx
@@ -203,7 +203,7 @@ const PROSPCaseList = ({
 
     const handleFileChange = (event: ChangeEvent<HTMLSelectElement>, p: any) => {
         const value = { ...p.value }
-        value[1] = event.currentTarget.selectedOptions[0].value
+        value[1] = event.currentTarget.selectedOptions[0].value || ""
         updateFileLink(p.node?.data.id, value[1])
         const rowNode = gridRef.current?.getRowNode(p.node?.data.id)
         if (value[1] === rowNode.data.sharePointFileId) {
@@ -216,8 +216,9 @@ const PROSPCaseList = ({
     }
 
     const fileSelectorRenderer = (p: any) => {
-        const fileId = p.value[1]
-        const items: DriveItem[] = p.value[0]
+        const fileId = p.value[1] || ""
+        const items: DriveItem[] = p.value[0] || []
+
         return (
             <NativeSelect
                 id="sharePointFile"
diff --git a/frontend/src/Components/Gallery/Gallery.tsx b/frontend/src/Components/Gallery/Gallery.tsx
index d22a04f2c..441867081 100644
--- a/frontend/src/Components/Gallery/Gallery.tsx
+++ b/frontend/src/Components/Gallery/Gallery.tsx
@@ -1,4 +1,4 @@
-import { useEffect, useState } from "react"
+import React, { useEffect, useState } from "react"
 import { Box, Grid } from "@mui/material"
 import styled from "styled-components"
 import { Icon, Button, Typography } from "@equinor/eds-core-react"
@@ -10,24 +10,22 @@ import { useAppContext } from "../../Context/AppContext"
 import { useProjectContext } from "../../Context/ProjectContext"
 import { getImageService } from "../../Services/ImageService"
 
-const Wrapper = styled(Grid)`
-    padding: 2px;
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(calc(25% - 20px), 1fr));
+const Wrapper = styled.div`
+    display: flex;
     justify-content: start;
     gap: 10px;
-    overflow: hidden;
     margin-bottom: 30px; 
+    width: 100%;
+    flex-wrap: wrap;
 `
 
 const ImageWithHover = styled(Box)`
     position: relative;
+    height: 240px;
+    border-radius: 5px;
+    border: 1px solid lightgray;
     & img {
-        width: 100%;
-        height: 200px;
-        object-fit: cover;
-        border-radius: 5px;
-        border: 1px solid lightgray;
+        height: 100%;
     }
     &:hover {
         img {
@@ -37,15 +35,14 @@ const ImageWithHover = styled(Box)`
     }
 `
 
-const Controls = styled(Box)`
+const Controls = styled.div`
     display: none;
     position: absolute;
-    top: 10px;
-    right: 10px;
+    top: 0;
+    right: 0;
     padding: 10px;
     gap: 5px;
     
-
     ${ImageWithHover}:hover & {
         display: flex;
     }
@@ -71,11 +68,16 @@ const Gallery = () => {
 
     useEffect(() => {
         const loadImages = async () => {
-            if (project?.id && caseId) {
+            if (project?.id) {
                 try {
                     const imageService = await getImageService()
-                    const imageDtos = await imageService.getImages(project.id, caseId)
-                    setGallery(imageDtos)
+                    if (caseId) {
+                        const imageDtos = await imageService.getImages(project.id, caseId)
+                        setGallery(imageDtos)
+                    } else {
+                        const imageDtos = await imageService.getProjectImages(project.id)
+                        setGallery(imageDtos)
+                    }
                 } catch (error) {
                     console.error("Error loading images:", error)
                 }
@@ -87,11 +89,15 @@ const Gallery = () => {
 
     const handleDelete = async (imageUrl: string) => {
         try {
-            if (project?.id && caseId) {
+            if (project?.id) {
                 const imageService = await getImageService()
                 const image = gallery.find((img) => img.url === imageUrl)
                 if (image) {
-                    await imageService.deleteImage(project.id, caseId, image.id)
+                    if (caseId) {
+                        await imageService.deleteImage(project.id, image.id, caseId)
+                    } else {
+                        await imageService.deleteImage(project.id, image.id)
+                    }
                     setGallery(gallery.filter((img) => img.url !== imageUrl))
                     setExeededLimit(false)
                 } else {
diff --git a/frontend/src/Components/Gallery/ImageUpload.tsx b/frontend/src/Components/Gallery/ImageUpload.tsx
index 9ab94249b..c80be1627 100644
--- a/frontend/src/Components/Gallery/ImageUpload.tsx
+++ b/frontend/src/Components/Gallery/ImageUpload.tsx
@@ -13,19 +13,18 @@ import { useAppContext } from "../../Context/AppContext"
 const UploadBox = styled(Box)`
     display: flex;
     align-items: center;
+    justify-content: center;
     flex-direction: column;
-    width: calc(100% - 40px);
-    height: 160px;
+    width: 240px;
+    height: 240px;
     border: 1px dashed ${tokens.colors.interactive.primary__resting.rgba};
     border-radius: 5px;
     cursor: pointer;
-    padding: 20px;
     transition: 0.3s;
     gap: 10px;
 
     & svg {
         fill: ${tokens.colors.interactive.primary__resting.rgba};
-        margin-top: 20px;
     }
 
     &:hover {
@@ -58,6 +57,7 @@ const ImageUpload: React.FC<ImageUploadProps> = ({ setGallery, gallery, setExeed
                     setGallery(imageDtos)
                 } catch (error) {
                     console.error("Error loading images:", error)
+                    setSnackBarMessage("Error loading images")
                 }
             }
         }
@@ -73,8 +73,6 @@ const ImageUpload: React.FC<ImageUploadProps> = ({ setGallery, gallery, setExeed
     }
 
     const onDrop = async (acceptedFiles: File[], fileRejections: FileRejection[]) => {
-        setSnackBarMessage("")
-
         fileRejections.forEach((rejection) => {
             const { file, errors } = rejection
             errors.forEach((error: { code: string }) => {
@@ -92,14 +90,14 @@ const ImageUpload: React.FC<ImageUploadProps> = ({ setGallery, gallery, setExeed
         }
         setExeededLimit(false)
 
-        if (!project?.id || !caseId) {
-            console.error("Project ID or Case ID is missing.")
+        if (!project?.id) {
+            console.error("Project ID is missing.")
             return
         }
 
         const imageService = await getImageService()
 
-        const uploadPromises = acceptedFiles.map((file) => imageService.uploadImage(project.id, project.name, caseId, file))
+        const uploadPromises = acceptedFiles.map((file) => imageService.uploadImage(project.id, project.name, file, caseId))
         try {
             const uploadedImageDtos = await Promise.all(uploadPromises)
             if (Array.isArray(uploadedImageDtos)) {
@@ -109,6 +107,7 @@ const ImageUpload: React.FC<ImageUploadProps> = ({ setGallery, gallery, setExeed
             }
         } catch (error) {
             console.error("Error uploading images:", error)
+            setSnackBarMessage("Error uploading images")
         }
     }
 
diff --git a/frontend/src/Components/Project/ProjectOverviewTab.tsx b/frontend/src/Components/Project/ProjectOverviewTab.tsx
index f7f140052..f296fba2b 100644
--- a/frontend/src/Components/Project/ProjectOverviewTab.tsx
+++ b/frontend/src/Components/Project/ProjectOverviewTab.tsx
@@ -14,6 +14,7 @@ import { useProjectContext } from "../../Context/ProjectContext"
 import CasesTable from "../Case/OverviewCasesTable/CasesTable"
 import { useModalContext } from "../../Context/ModalContext"
 import { useAppContext } from "../../Context/AppContext"
+import Gallery from "../Gallery/Gallery"
 
 const ProjectOverviewTab = () => {
     const { editMode } = useAppContext()
@@ -54,6 +55,7 @@ const ProjectOverviewTab = () => {
 
     return (
         <Grid container columnSpacing={2} rowSpacing={3}>
+            <Gallery />
             <Grid item xs={12} container spacing={1} justifyContent="space-between">
                 <Grid item>
                     <Typography group="input" variant="label">Project Phase</Typography>
diff --git a/frontend/src/Hooks/useDataEdits.tsx b/frontend/src/Hooks/useDataEdits.tsx
index 0636c820b..c6d962841 100644
--- a/frontend/src/Hooks/useDataEdits.tsx
+++ b/frontend/src/Hooks/useDataEdits.tsx
@@ -96,12 +96,7 @@ const useDataEdits = (): {
                 variables,
             ) => {
                 const { projectId, caseId } = variables
-                /* this should work but doesnt :(
-                const assetId = caseId === results.id ? "" : results.id
-                queryClient.setQueryData([{ caseId, projectId , assetId }], results)
-                */
 
-                // this makes the app refetch all data. We should only refetch the data that was updated in the future.
                 queryClient.fetchQuery(["apiData", { projectId, caseId }])
             },
             onError: (error: any) => {
diff --git a/frontend/src/Services/CaseWithAssetsService.ts b/frontend/src/Services/CaseWithAssetsService.ts
deleted file mode 100644
index ce4c0ca64..000000000
--- a/frontend/src/Services/CaseWithAssetsService.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { __BaseService } from "./__BaseService"
-
-import { config } from "./config"
-
-import { getToken, loginAccessTokenKey } from "../Utils/common"
-
-class CaseWithAssetsService extends __BaseService {
-    public async update(projectId: string, caseId: string, body: any): Promise<Components.Schemas.ProjectWithGeneratedProfilesDto> {
-        const res: Components.Schemas.ProjectWithGeneratedProfilesDto = await this.post(`projects/${projectId}/cases/${caseId}/case-with-assets`, { body })
-        return res
-    }
-}
-
-export const GetCaseWithAssetsService = async () => new CaseWithAssetsService({
-    ...config.CaseWithAssetsService,
-    accessToken: await getToken(loginAccessTokenKey)!,
-})
diff --git a/frontend/src/Services/ImageService.tsx b/frontend/src/Services/ImageService.tsx
index 51dec2449..635e90754 100644
--- a/frontend/src/Services/ImageService.tsx
+++ b/frontend/src/Services/ImageService.tsx
@@ -2,13 +2,18 @@ import { __BaseService } from "./__BaseService"
 import { config } from "./config"
 import { getToken, loginAccessTokenKey } from "../Utils/common"
 
+const projectUrl = (projectId: string) => `projects/${projectId}/images`
+const caseUrl = (projectId: string, caseId: string) => `projects/${projectId}/cases/${caseId}/images`
+
 export class ImageService extends __BaseService {
-    public async uploadImage(projectId: string, projectName: string, caseId: string, file: File): Promise<Components.Schemas.ImageDto> {
+    public async uploadImage(projectId: string, projectName: string, file: File, caseId?: string): Promise<Components.Schemas.ImageDto> {
         const formData = new FormData()
         formData.append("image", file)
         formData.append("projectName", projectName)
 
-        const response = await this.post(`projects/${projectId}/cases/${caseId}/images`, {
+        console.log("level:", caseId ? "case" : "project")
+        console.log("url:", caseId ? caseUrl(projectId, caseId) : projectUrl(projectId))
+        const response = await this.post(caseId ? caseUrl(projectId, caseId) : projectUrl(projectId), {
             body: formData,
         })
         if (response) {
@@ -18,13 +23,42 @@ export class ImageService extends __BaseService {
         throw new Error("Upload image response data is undefined")
     }
 
-    public async getImages(projectId: string, caseId: string): Promise < Components.Schemas.ImageDto[] > {
-        const response = await this.get(`projects/${projectId}/cases/${caseId}/images`)
+    public async getImages(projectId: string, caseId?: string): Promise<Components.Schemas.ImageDto[]> {
+        const response = await this.get(caseId ? caseUrl(projectId, caseId) : projectUrl(projectId))
         return response
     }
 
-    public async deleteImage(projectId: string, caseId: string, imageId: string): Promise<void> {
-        await this.delete(`projects/${projectId}/cases/${caseId}/images/${imageId}`)
+    public async deleteImage(projectId: string, imageId: string, caseId?: string): Promise<void> {
+        try {
+            if (caseId) {
+                await this.delete(`projects/${projectId}/cases/${caseId}/images/${imageId}`)
+            } else {
+                await this.delete(`projects/${projectId}/images/${imageId}`)
+            }
+        } catch (error) {
+            throw new Error(`Error deleting image: ${error}`)
+        }
+    }
+
+    public async uploadProjectImage(projectId: string, projectName: string, file: File): Promise<Components.Schemas.ImageDto> {
+        const formData = new FormData()
+        formData.append("image", file)
+        formData.append("projectName", projectName)
+
+        const response = await this.post(projectUrl(projectId), {
+            body: formData,
+        })
+
+        if (response) {
+            return response
+        }
+
+        throw new Error("Upload project image response data is undefined")
+    }
+
+    public async getProjectImages(projectId: string): Promise<Components.Schemas.ImageDto[]> {
+        const response = await this.get(projectUrl(projectId))
+        return response
     }
 }
 
diff --git a/frontend/src/Views/ProjectView.tsx b/frontend/src/Views/ProjectView.tsx
index 94fa73a29..b2f2290a9 100644
--- a/frontend/src/Views/ProjectView.tsx
+++ b/frontend/src/Views/ProjectView.tsx
@@ -28,7 +28,7 @@ const ProjectView = () => {
                     <List>
                         <Tab>Overview </Tab>
                         <Tab>Compare cases</Tab>
-                        <Tab>Case edit history</Tab>
+                        {/* comment out for qa release <Tab>Case edit history</Tab> */}
                         <Tab>Settings</Tab>
                     </List>
                     <Panels>
diff --git a/frontend/src/types.d.ts b/frontend/src/types.d.ts
index fa1436344..f7063c994 100644
--- a/frontend/src/types.d.ts
+++ b/frontend/src/types.d.ts
@@ -84,18 +84,6 @@ declare namespace Components {
             maturity?: Maturity /* int32 */;
             approvedBy?: string | null;
         }
-        export interface APIUpdateSubstructureWithProfilesDto {
-            dryWeight?: number; // double
-            currency?: Currency /* int32 */;
-            costYear?: number; // int32
-            source?: Source /* int32 */;
-            concept?: Concept /* int32 */;
-            dG3Date?: string | null; // date-time
-            dG4Date?: string | null; // date-time
-            costProfileOverride?: UpdateSubstructureCostProfileOverrideDto;
-            maturity?: Maturity /* int32 */;
-            approvedBy?: string | null;
-        }
         export interface APIUpdateSurfDto {
             cessationCost?: number; // double
             infieldPipelineSystemLength?: number; // double
@@ -115,26 +103,6 @@ declare namespace Components {
             dG4Date?: string | null; // date-time
             maturity?: Maturity /* int32 */;
         }
-        export interface APIUpdateSurfWithProfilesDto {
-            cessationCost?: number; // double
-            infieldPipelineSystemLength?: number; // double
-            umbilicalSystemLength?: number; // double
-            artificialLift?: ArtificialLift /* int32 */;
-            riserCount?: number; // int32
-            templateCount?: number; // int32
-            producerCount?: number; // int32
-            gasInjectorCount?: number; // int32
-            waterInjectorCount?: number; // int32
-            productionFlowline?: ProductionFlowline /* int32 */;
-            currency?: Currency /* int32 */;
-            costYear?: number; // int32
-            source?: Source /* int32 */;
-            approvedBy?: string | null;
-            dG3Date?: string | null; // date-time
-            dG4Date?: string | null; // date-time
-            costProfileOverride?: UpdateSurfCostProfileOverrideDto;
-            maturity?: Maturity /* int32 */;
-        }
         export interface APIUpdateTopsideDto {
             dryWeight?: number; // double
             oilCapacity?: number; // double
@@ -162,34 +130,6 @@ declare namespace Components {
             maturity?: Maturity /* int32 */;
             approvedBy?: string | null;
         }
-        export interface APIUpdateTopsideWithProfilesDto {
-            dryWeight?: number; // double
-            oilCapacity?: number; // double
-            gasCapacity?: number; // double
-            waterInjectionCapacity?: number; // double
-            artificialLift?: ArtificialLift /* int32 */;
-            currency?: Currency /* int32 */;
-            fuelConsumption?: number; // double
-            flaredGas?: number; // double
-            producerCount?: number; // int32
-            gasInjectorCount?: number; // int32
-            waterInjectorCount?: number; // int32
-            cO2ShareOilProfile?: number; // double
-            cO2ShareGasProfile?: number; // double
-            cO2ShareWaterInjectionProfile?: number; // double
-            cO2OnMaxOilProfile?: number; // double
-            cO2OnMaxGasProfile?: number; // double
-            cO2OnMaxWaterInjectionProfile?: number; // double
-            costYear?: number; // int32
-            dG3Date?: string | null; // date-time
-            dG4Date?: string | null; // date-time
-            facilityOpex?: number; // double
-            peakElectricityImported?: number; // double
-            source?: Source /* int32 */;
-            costProfileOverride?: UpdateTopsideCostProfileOverrideDto;
-            maturity?: Maturity /* int32 */;
-            approvedBy?: string | null;
-        }
         export interface APIUpdateTransportDto {
             gasExportPipelineLength?: number; // double
             oilExportPipelineLength?: number; // double
@@ -200,17 +140,6 @@ declare namespace Components {
             source?: Source /* int32 */;
             maturity?: Maturity /* int32 */;
         }
-        export interface APIUpdateTransportWithProfilesDto {
-            gasExportPipelineLength?: number; // double
-            oilExportPipelineLength?: number; // double
-            currency?: Currency /* int32 */;
-            costYear?: number; // int32
-            dG3Date?: string | null; // date-time
-            dG4Date?: string | null; // date-time
-            source?: Source /* int32 */;
-            costProfileOverride?: UpdateTransportCostProfileOverrideDto;
-            maturity?: Maturity /* int32 */;
-        }
         export interface AdditionalOPEXCostProfileDto {
             id: string; // uuid
             startYear: number; // int32
@@ -357,18 +286,6 @@ declare namespace Components {
             gasInjectorCostProfile?: GasInjectorCostProfileDto;
             gasInjectorCostProfileOverride?: GasInjectorCostProfileOverrideDto;
         }
-        export interface CaseWithAssetsWrapperDto {
-            caseDto?: APIUpdateCaseWithProfilesDto;
-            drainageStrategyDto?: UpdateDrainageStrategyWithProfilesDto;
-            wellProjectDto?: UpdateWellProjectWithProfilesDto;
-            explorationDto?: UpdateExplorationWithProfilesDto;
-            surfDto?: APIUpdateSurfWithProfilesDto;
-            substructureDto?: APIUpdateSubstructureWithProfilesDto;
-            topsideDto?: APIUpdateTopsideWithProfilesDto;
-            transportDto?: APIUpdateTransportWithProfilesDto;
-            wellProjectWellDtos?: UpdateWellProjectWellWithScheduleDto[] | null;
-            explorationWellDto?: UpdateExplorationWellDto[] | null;
-        }
         export interface CaseWithProfilesDto {
             id: string; // uuid
             projectId: string; // uuid
@@ -436,12 +353,6 @@ declare namespace Components {
             epaVersion: string;
             currency: Currency /* int32 */;
         }
-        export interface CessationCostWrapperDto {
-            cessationCostDto?: CessationCostDto;
-            cessationWellsCostDto?: CessationWellsCostDto;
-            cessationOffshoreFacilitiesCostDto?: CessationOffshoreFacilitiesCostDto;
-            cessationOnshoreFacilitiesCostProfileDto?: CessationOnshoreFacilitiesCostProfileDto;
-        }
         export interface CessationOffshoreFacilitiesCostDto {
             id: string; // uuid
             startYear: number; // int32
@@ -910,16 +821,6 @@ declare namespace Components {
             override: boolean;
         }
         export type GasSolution = 0 | 1; // int32
-        export interface GeneratedProfilesDto {
-            studyCostProfileWrapperDto?: StudyCostProfileWrapperDto;
-            opexCostProfileWrapperDto?: OpexCostProfileWrapperDto;
-            cessationCostWrapperDto?: CessationCostWrapperDto;
-            co2EmissionsDto?: Co2EmissionsDto;
-            gAndGAdminCostDto?: GAndGAdminCostDto;
-            importedElectricityDto?: ImportedElectricityDto;
-            fuelFlaringAndLossesDto?: FuelFlaringAndLossesDto;
-            netSalesGasDto?: NetSalesGasDto;
-        }
         export interface HistoricCostCostProfileDto {
             id: string; // uuid
             startYear: number; // int32
@@ -1035,14 +936,6 @@ declare namespace Components {
             epaVersion: string;
             currency: Currency /* int32 */;
         }
-        export interface OpexCostProfileWrapperDto {
-            opexCostProfileDto?: OpexCostProfileDto;
-            historicCostCostProfileDto?: HistoricCostCostProfileDto;
-            wellInterventionCostProfileDto?: WellInterventionCostProfileDto;
-            offshoreFacilitiesOperationsCostProfileDto?: OffshoreFacilitiesOperationsCostProfileDto;
-            onshoreRelatedOPEXCostProfileDto?: OnshoreRelatedOPEXCostProfileDto;
-            additionalOPEXCostProfileDto?: AdditionalOPEXCostProfileDto;
-        }
         export type PhysUnit = 0 | 1; // int32
         export interface ProductionAndSalesVolumesDto {
             startYear?: number; // int32
@@ -1121,10 +1014,6 @@ declare namespace Components {
             averageDevelopmentDrillingDays: number; // double
         }
         export type ProjectPhase = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; // int32
-        export interface ProjectWithGeneratedProfilesDto {
-            projectDto: ProjectDto;
-            generatedProfilesDto: GeneratedProfilesDto;
-        }
         export interface STEACaseDto {
             name?: string | null;
             startYear?: number; // int32
@@ -1197,12 +1086,6 @@ declare namespace Components {
             epaVersion: string;
             currency: Currency /* int32 */;
         }
-        export interface StudyCostProfileWrapperDto {
-            studyCostProfileDto?: StudyCostProfileDto;
-            totalFeasibilityAndConceptStudiesDto?: TotalFeasibilityAndConceptStudiesDto;
-            totalFEEDStudiesDto?: TotalFEEDStudiesDto;
-            totalOtherStudiesCostProfileDto?: TotalOtherStudiesCostProfileDto;
-        }
         export interface SubstructureCessationCostProfileDto {
             id: string; // uuid
             startYear: number; // int32
@@ -1606,26 +1489,6 @@ declare namespace Components {
             artificialLift?: ArtificialLift /* int32 */;
             gasSolution?: GasSolution /* int32 */;
         }
-        export interface UpdateDrainageStrategyWithProfilesDto {
-            name?: string | null;
-            description?: string | null;
-            nglYield?: number; // double
-            producerCount?: number; // int32
-            gasInjectorCount?: number; // int32
-            waterInjectorCount?: number; // int32
-            artificialLift?: ArtificialLift /* int32 */;
-            gasSolution?: GasSolution /* int32 */;
-            productionProfileOil?: UpdateProductionProfileOilDto;
-            productionProfileGas?: UpdateProductionProfileGasDto;
-            productionProfileWater?: UpdateProductionProfileWaterDto;
-            productionProfileWaterInjection?: UpdateProductionProfileWaterInjectionDto;
-            fuelFlaringAndLossesOverride?: UpdateFuelFlaringAndLossesOverrideDto;
-            netSalesGasOverride?: UpdateNetSalesGasOverrideDto;
-            importedelectricityOverride?: UpdateImportedElectricityOverrideDto;
-            co2EmissionsOverride?: UpdateCo2EmissionsOverrideDto;
-            deferredOilProduction?: UpdateDeferredOilProductionDto;
-            deferredGasProduction?: UpdateDeferredGasProductionDto;
-        }
         export interface UpdateDrillingScheduleDto {
             startYear?: number; // int32
             values?: number /* int32 */[] | null;
@@ -1646,11 +1509,6 @@ declare namespace Components {
             values?: number /* double */[] | null;
             currency?: Currency /* int32 */;
         }
-        export interface UpdateExplorationWellDto {
-            drillingSchedule?: UpdateDrillingScheduleDto;
-            explorationId: string; // uuid
-            wellId: string; // uuid
-        }
         export interface UpdateExplorationWithProfilesDto {
             name?: string | null;
             rigMobDemob?: number; // double
@@ -1842,11 +1700,6 @@ declare namespace Components {
             artificialLift?: ArtificialLift /* int32 */;
             currency?: Currency /* int32 */;
         }
-        export interface UpdateWellProjectWellWithScheduleDto {
-            drillingSchedule?: DrillingScheduleDto;
-            wellProjectId: string; // uuid
-            wellId: string; // uuid
-        }
         export interface UpdateWellProjectWithProfilesDto {
             name?: string | null;
             oilProducerCostProfileOverride?: UpdateOilProducerCostProfileOverrideDto;
@@ -2137,21 +1990,6 @@ declare namespace Paths {
             }
         }
     }
-    namespace Projects$ProjectIdCases$CaseIdCessation {
-        namespace Get {
-            namespace Parameters {
-                export type CaseId = string; // uuid
-                export type ProjectId = string;
-            }
-            export interface PathParameters {
-                caseId: Parameters.CaseId /* uuid */;
-                projectId: Parameters.ProjectId;
-            }
-            namespace Responses {
-                export type $200 = Components.Schemas.CessationCostWrapperDto;
-            }
-        }
-    }
     namespace Projects$ProjectIdCases$CaseIdCessationOffshoreFacilitiesCostOverride {
         namespace Post {
             namespace Parameters {
@@ -2947,14 +2785,14 @@ declare namespace Paths {
     namespace Projects$ProjectIdCases$CaseIdImages$ImageId {
         namespace Delete {
             namespace Parameters {
-                export type CaseId = string; // uuid
+                export type CaseId = string;
                 export type ImageId = string; // uuid
-                export type ProjectId = string; // uuid
+                export type ProjectId = string;
             }
             export interface PathParameters {
-                projectId: Parameters.ProjectId /* uuid */;
-                caseId: Parameters.CaseId /* uuid */;
                 imageId: Parameters.ImageId /* uuid */;
+                projectId: Parameters.ProjectId;
+                caseId: Parameters.CaseId;
             }
             namespace Responses {
                 export interface $200 {
@@ -3030,36 +2868,6 @@ declare namespace Paths {
             }
         }
     }
-    namespace Projects$ProjectIdCases$CaseIdOpex {
-        namespace Get {
-            namespace Parameters {
-                export type CaseId = string; // uuid
-                export type ProjectId = string;
-            }
-            export interface PathParameters {
-                caseId: Parameters.CaseId /* uuid */;
-                projectId: Parameters.ProjectId;
-            }
-            namespace Responses {
-                export type $200 = Components.Schemas.OpexCostProfileWrapperDto;
-            }
-        }
-    }
-    namespace Projects$ProjectIdCases$CaseIdStudy {
-        namespace Get {
-            namespace Parameters {
-                export type CaseId = string; // uuid
-                export type ProjectId = string;
-            }
-            export interface PathParameters {
-                caseId: Parameters.CaseId /* uuid */;
-                projectId: Parameters.ProjectId;
-            }
-            namespace Responses {
-                export type $200 = Components.Schemas.StudyCostProfileWrapperDto;
-            }
-        }
-    }
     namespace Projects$ProjectIdCases$CaseIdSubstructures$SubstructureId {
         namespace Put {
             namespace Parameters {
@@ -3648,6 +3456,57 @@ declare namespace Paths {
             }
         }
     }
+    namespace Projects$ProjectIdImages {
+        namespace Get {
+            namespace Parameters {
+                export type ProjectId = string; // uuid
+            }
+            export interface PathParameters {
+                projectId: Parameters.ProjectId /* uuid */;
+            }
+            namespace Responses {
+                export type $200 = Components.Schemas.ImageDto[];
+            }
+        }
+        namespace Post {
+            namespace Parameters {
+                export type ProjectId = string; // uuid
+            }
+            export interface PathParameters {
+                projectId: Parameters.ProjectId /* uuid */;
+            }
+            export interface RequestBody {
+                projectName?: string;
+                ContentType?: string;
+                ContentDisposition?: string;
+                Headers?: {
+                    [name: string]: string[];
+                };
+                Length?: number; // int64
+                Name?: string;
+                FileName?: string;
+            }
+            namespace Responses {
+                export type $200 = Components.Schemas.ImageDto;
+            }
+        }
+    }
+    namespace Projects$ProjectIdImages$ImageId {
+        namespace Delete {
+            namespace Parameters {
+                export type ImageId = string; // uuid
+                export type ProjectId = string;
+            }
+            export interface PathParameters {
+                imageId: Parameters.ImageId /* uuid */;
+                projectId: Parameters.ProjectId;
+            }
+            namespace Responses {
+                export interface $200 {
+                }
+            }
+        }
+    }
     namespace Projects$ProjectIdTechnicalInput {
         namespace Put {
             namespace Parameters {
@@ -3678,18 +3537,4 @@ declare namespace Paths {
             }
         }
     }
-    namespace UpdateCaseWithAssets {
-        namespace Parameters {
-            export type CaseId = string; // uuid
-            export type ProjectId = string; // uuid
-        }
-        export interface PathParameters {
-            projectId: Parameters.ProjectId /* uuid */;
-            caseId: Parameters.CaseId /* uuid */;
-        }
-        export type RequestBody = Components.Schemas.CaseWithAssetsWrapperDto;
-        namespace Responses {
-            export type $200 = Components.Schemas.ProjectWithGeneratedProfilesDto;
-        }
-    }
 }