diff --git a/Controllers/AuthController.cs b/Controllers/AuthController.cs
index da263d3..e855953 100644
--- a/Controllers/AuthController.cs
+++ b/Controllers/AuthController.cs
@@ -1,6 +1,7 @@
 using Microsoft.AspNetCore.Mvc;
 using ValuationBackend.Models;
 using ValuationBackend.Services;
+using System.Threading.Tasks;
 
 namespace ValuationBackend.Controllers
 {
@@ -9,10 +10,12 @@ namespace ValuationBackend.Controllers
     public class AuthController : ControllerBase
     {
         private readonly IAuthService _authService;
+        private readonly PasswordResetService _passwordResetService;
 
-        public AuthController(IAuthService authService)
+        public AuthController(IAuthService authService, PasswordResetService passwordResetService)
         {
             _authService = authService;
+            _passwordResetService = passwordResetService;
         }
 
         [HttpPost("login")]
@@ -46,14 +49,34 @@ public async Task<IActionResult> Logout([FromBody] LogoutRequest request)
             return Ok(new { msg = "success" });
         }
 
-        [HttpPost("forgot-password")]
-        public async Task<IActionResult> ForgotPassword([FromBody] ForgotPasswordRequest request)
+        // --- New Password Reset Endpoints ---
+
+        [HttpPost("request-password-reset")]
+        public async Task<IActionResult> RequestPasswordReset([FromBody] EmailDto dto)
         {
-            var result = await _authService.ForgotPasswordAsync(request.Username);
-            if (!result)
-                return NotFound(new { msg = "User not found" });
+            await _passwordResetService.RequestPasswordResetAsync(dto.Email);
+            return Ok(new { message = "If the email exists, an OTP has been sent." });
+        }
 
-            return Ok(new { msg = "success" });
+        [HttpPost("verify-otp")]
+        public async Task<IActionResult> VerifyOtp([FromBody] OtpDto dto)
+        {
+            var valid = await _passwordResetService.VerifyOtpAsync(dto.Email, dto.Otp);
+            if (!valid) return BadRequest(new { message = "Invalid or expired OTP." });
+            return Ok(new { message = "OTP verified." });
         }
+
+        [HttpPost("reset-password")]
+        public async Task<IActionResult> ResetPassword([FromBody] ResetPasswordDto dto)
+        {
+            var success = await _passwordResetService.ResetPasswordAsync(dto.Email, dto.Otp, dto.NewPassword);
+            if (!success) return BadRequest(new { message = "Invalid OTP or email." });
+            return Ok(new { message = "Password reset successful." });
+        }
+
+        // --- DTOs for password reset ---
+        public class EmailDto { public string Email { get; set; } }
+        public class OtpDto { public string Email { get; set; } public string Otp { get; set; } }
+        public class ResetPasswordDto { public string Email { get; set; } public string Otp { get; set; } public string NewPassword { get; set; } }
     }
 }
diff --git a/Controllers/DataMigrationController.cs b/Controllers/DataMigrationController.cs
new file mode 100644
index 0000000..62f155d
--- /dev/null
+++ b/Controllers/DataMigrationController.cs
@@ -0,0 +1,69 @@
+using Microsoft.AspNetCore.Mvc;
+using ValuationBackend.Data;
+
+namespace ValuationBackend.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class DataMigrationController : ControllerBase
+    {
+        private readonly AppDbContext _context;
+
+        public DataMigrationController(AppDbContext context)
+        {
+            _context = context;
+        }
+
+        /// <summary>
+        /// Populates foreign keys for LM Rental Evidence records based on existing string references
+        /// </summary>
+        [HttpPost("populate-lm-rental-evidence-foreign-keys")]
+        public async Task<IActionResult> PopulateLMRentalEvidenceForeignKeys()
+        {
+            try
+            {
+                await PopulateForeignKeysMigration.PopulateLMRentalEvidenceForeignKeys(_context);
+                return Ok(new { message = "Foreign keys populated successfully for LM Rental Evidence." });
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, new { error = "Failed to populate foreign keys", details = ex.Message });
+            }
+        }
+
+        /// <summary>
+        /// Validates foreign key relationships for LM Rental Evidence
+        /// </summary>
+        [HttpGet("validate-lm-rental-evidence-foreign-keys")]
+        public async Task<IActionResult> ValidateLMRentalEvidenceForeignKeys()
+        {
+            try
+            {
+                await PopulateForeignKeysMigration.ValidateForeignKeyRelationships(_context);
+                return Ok(new { message = "Foreign key validation completed. Check console output for details." });
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, new { error = "Failed to validate foreign keys", details = ex.Message });
+            }
+        }
+
+        /// <summary>
+        /// Runs both population and validation in sequence
+        /// </summary>
+        [HttpPost("migrate-lm-rental-evidence")]
+        public async Task<IActionResult> MigrateLMRentalEvidence()
+        {
+            try
+            {
+                await PopulateForeignKeysMigration.PopulateLMRentalEvidenceForeignKeys(_context);
+                await PopulateForeignKeysMigration.ValidateForeignKeyRelationships(_context);
+                return Ok(new { message = "LM Rental Evidence migration completed successfully." });
+            }
+            catch (Exception ex)
+            {
+                return StatusCode(500, new { error = "Failed to migrate LM Rental Evidence", details = ex.Message });
+            }
+        }
+    }
+}
diff --git a/Controllers/LACoordinateControllers.cs b/Controllers/LACoordinateControllers.cs
new file mode 100644
index 0000000..e7b9f0d
--- /dev/null
+++ b/Controllers/LACoordinateControllers.cs
@@ -0,0 +1,416 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models.DTOs;
+using ValuationBackend.Services;
+
+namespace ValuationBackend.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class PastValuationsLACoordinateController : ControllerBase
+    {
+        private readonly IPastValuationsLACoordinateService _coordinateService;
+
+        public PastValuationsLACoordinateController(IPastValuationsLACoordinateService coordinateService)
+        {
+            _coordinateService = coordinateService;
+        }
+
+        // GET: api/PastValuationsLACoordinate
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<PastValuationsLACoordinateResponseDto>>> GetCoordinates()
+        {
+            var coordinates = await _coordinateService.GetAllAsync();
+            return Ok(coordinates);
+        }
+
+        // GET: api/PastValuationsLACoordinate/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<PastValuationsLACoordinateResponseDto>> GetCoordinate(int id)
+        {
+            var coordinate = await _coordinateService.GetByIdAsync(id);
+
+            if (coordinate == null)
+            {
+                return NotFound($"Coordinate with ID {id} not found.");
+            }
+
+            return Ok(coordinate);
+        }
+
+        // GET: api/PastValuationsLACoordinate/pastvaluation/5
+        [HttpGet("pastvaluation/{pastValuationId}")]
+        public async Task<ActionResult<IEnumerable<PastValuationsLACoordinateResponseDto>>> GetCoordinatesByPastValuationId(int pastValuationId)
+        {
+            var coordinates = await _coordinateService.GetByPastValuationIdAsync(pastValuationId);
+            return Ok(coordinates);
+        }
+
+        // GET: api/PastValuationsLACoordinate/masterfile/5
+        [HttpGet("masterfile/{masterfileId}")]
+        public async Task<ActionResult<IEnumerable<PastValuationsLACoordinateResponseDto>>> GetCoordinatesByMasterfileId(int masterfileId)
+        {
+            var coordinates = await _coordinateService.GetByMasterfileIdAsync(masterfileId);
+            return Ok(coordinates);
+        }
+
+        // POST: api/PastValuationsLACoordinate
+        [HttpPost]
+        public async Task<ActionResult<PastValuationsLACoordinateResponseDto>> CreateCoordinate(PastValuationsLACoordinateCreateDto dto)
+        {
+            try
+            {
+                var createdCoordinate = await _coordinateService.CreateAsync(dto);
+                return CreatedAtAction(nameof(GetCoordinate), new { id = createdCoordinate.Id }, createdCoordinate);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // PUT: api/PastValuationsLACoordinate/5
+        [HttpPut("{id}")]
+        public async Task<ActionResult<PastValuationsLACoordinateResponseDto>> UpdateCoordinate(int id, PastValuationsLACoordinateUpdateDto dto)
+        {
+            try
+            {
+                var updatedCoordinate = await _coordinateService.UpdateAsync(id, dto);
+                if (updatedCoordinate == null)
+                {
+                    return NotFound($"Coordinate with ID {id} not found.");
+                }
+
+                return Ok(updatedCoordinate);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (InvalidOperationException ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
+        }
+
+        // DELETE: api/PastValuationsLACoordinate/5
+        [HttpDelete("{id}")]
+        public async Task<ActionResult> DeleteCoordinate(int id)
+        {
+            var result = await _coordinateService.DeleteAsync(id);
+            if (!result)
+            {
+                return NotFound($"Coordinate with ID {id} not found.");
+            }
+
+            return NoContent();
+        }
+    }
+
+    [Route("api/[controller]")]
+    [ApiController]
+    public class BuildingRatesLACoordinateController : ControllerBase
+    {
+        private readonly IBuildingRatesLACoordinateService _coordinateService;
+
+        public BuildingRatesLACoordinateController(IBuildingRatesLACoordinateService coordinateService)
+        {
+            _coordinateService = coordinateService;
+        }
+
+        // GET: api/BuildingRatesLACoordinate
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<BuildingRatesLACoordinateResponseDto>>> GetCoordinates()
+        {
+            var coordinates = await _coordinateService.GetAllAsync();
+            return Ok(coordinates);
+        }
+
+        // GET: api/BuildingRatesLACoordinate/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<BuildingRatesLACoordinateResponseDto>> GetCoordinate(int id)
+        {
+            var coordinate = await _coordinateService.GetByIdAsync(id);
+
+            if (coordinate == null)
+            {
+                return NotFound($"Coordinate with ID {id} not found.");
+            }
+
+            return Ok(coordinate);
+        }
+
+        // GET: api/BuildingRatesLACoordinate/buildingrate/5
+        [HttpGet("buildingrate/{buildingRateId}")]
+        public async Task<ActionResult<IEnumerable<BuildingRatesLACoordinateResponseDto>>> GetCoordinatesByBuildingRateId(int buildingRateId)
+        {
+            var coordinates = await _coordinateService.GetByBuildingRateIdAsync(buildingRateId);
+            return Ok(coordinates);
+        }
+
+        // GET: api/BuildingRatesLACoordinate/masterfile/5
+        [HttpGet("masterfile/{masterfileId}")]
+        public async Task<ActionResult<IEnumerable<BuildingRatesLACoordinateResponseDto>>> GetCoordinatesByMasterfileId(int masterfileId)
+        {
+            var coordinates = await _coordinateService.GetByMasterfileIdAsync(masterfileId);
+            return Ok(coordinates);
+        }
+
+        // POST: api/BuildingRatesLACoordinate
+        [HttpPost]
+        public async Task<ActionResult<BuildingRatesLACoordinateResponseDto>> CreateCoordinate(BuildingRatesLACoordinateCreateDto dto)
+        {
+            try
+            {
+                var createdCoordinate = await _coordinateService.CreateAsync(dto);
+                return CreatedAtAction(nameof(GetCoordinate), new { id = createdCoordinate.Id }, createdCoordinate);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // PUT: api/BuildingRatesLACoordinate/5
+        [HttpPut("{id}")]
+        public async Task<ActionResult<BuildingRatesLACoordinateResponseDto>> UpdateCoordinate(int id, BuildingRatesLACoordinateUpdateDto dto)
+        {
+            try
+            {
+                var updatedCoordinate = await _coordinateService.UpdateAsync(id, dto);
+                if (updatedCoordinate == null)
+                {
+                    return NotFound($"Coordinate with ID {id} not found.");
+                }
+
+                return Ok(updatedCoordinate);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (InvalidOperationException ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
+        }
+
+        // DELETE: api/BuildingRatesLACoordinate/5
+        [HttpDelete("{id}")]
+        public async Task<ActionResult> DeleteCoordinate(int id)
+        {
+            var result = await _coordinateService.DeleteAsync(id);
+            if (!result)
+            {
+                return NotFound($"Coordinate with ID {id} not found.");
+            }
+
+            return NoContent();
+        }
+    }
+
+    [Route("api/[controller]")]
+    [ApiController]
+    public class SalesEvidenceLACoordinateController : ControllerBase
+    {
+        private readonly ISalesEvidenceLACoordinateService _coordinateService;
+
+        public SalesEvidenceLACoordinateController(ISalesEvidenceLACoordinateService coordinateService)
+        {
+            _coordinateService = coordinateService;
+        }
+
+        // GET: api/SalesEvidenceLACoordinate
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<SalesEvidenceLACoordinateResponseDto>>> GetCoordinates()
+        {
+            var coordinates = await _coordinateService.GetAllAsync();
+            return Ok(coordinates);
+        }
+
+        // GET: api/SalesEvidenceLACoordinate/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<SalesEvidenceLACoordinateResponseDto>> GetCoordinate(int id)
+        {
+            var coordinate = await _coordinateService.GetByIdAsync(id);
+
+            if (coordinate == null)
+            {
+                return NotFound($"Coordinate with ID {id} not found.");
+            }
+
+            return Ok(coordinate);
+        }
+
+        // GET: api/SalesEvidenceLACoordinate/salesevidence/5
+        [HttpGet("salesevidence/{salesEvidenceId}")]
+        public async Task<ActionResult<IEnumerable<SalesEvidenceLACoordinateResponseDto>>> GetCoordinatesBySalesEvidenceId(int salesEvidenceId)
+        {
+            var coordinates = await _coordinateService.GetBySalesEvidenceIdAsync(salesEvidenceId);
+            return Ok(coordinates);
+        }
+
+        // GET: api/SalesEvidenceLACoordinate/masterfile/5
+        [HttpGet("masterfile/{masterfileId}")]
+        public async Task<ActionResult<IEnumerable<SalesEvidenceLACoordinateResponseDto>>> GetCoordinatesByMasterfileId(int masterfileId)
+        {
+            var coordinates = await _coordinateService.GetByMasterfileIdAsync(masterfileId);
+            return Ok(coordinates);
+        }
+
+        // POST: api/SalesEvidenceLACoordinate
+        [HttpPost]
+        public async Task<ActionResult<SalesEvidenceLACoordinateResponseDto>> CreateCoordinate(SalesEvidenceLACoordinateCreateDto dto)
+        {
+            try
+            {
+                var createdCoordinate = await _coordinateService.CreateAsync(dto);
+                return CreatedAtAction(nameof(GetCoordinate), new { id = createdCoordinate.Id }, createdCoordinate);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // PUT: api/SalesEvidenceLACoordinate/5
+        [HttpPut("{id}")]
+        public async Task<ActionResult<SalesEvidenceLACoordinateResponseDto>> UpdateCoordinate(int id, SalesEvidenceLACoordinateUpdateDto dto)
+        {
+            try
+            {
+                var updatedCoordinate = await _coordinateService.UpdateAsync(id, dto);
+                if (updatedCoordinate == null)
+                {
+                    return NotFound($"Coordinate with ID {id} not found.");
+                }
+
+                return Ok(updatedCoordinate);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (InvalidOperationException ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
+        }
+
+        // DELETE: api/SalesEvidenceLACoordinate/5
+        [HttpDelete("{id}")]
+        public async Task<ActionResult> DeleteCoordinate(int id)
+        {
+            var result = await _coordinateService.DeleteAsync(id);
+            if (!result)
+            {
+                return NotFound($"Coordinate with ID {id} not found.");
+            }
+
+            return NoContent();
+        }
+    }
+
+    [Route("api/[controller]")]
+    [ApiController]
+    public class RentalEvidenceLACoordinateController : ControllerBase
+    {
+        private readonly IRentalEvidenceLACoordinateService _coordinateService;
+
+        public RentalEvidenceLACoordinateController(IRentalEvidenceLACoordinateService coordinateService)
+        {
+            _coordinateService = coordinateService;
+        }
+
+        // GET: api/RentalEvidenceLACoordinate
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<RentalEvidenceLACoordinateResponseDto>>> GetCoordinates()
+        {
+            var coordinates = await _coordinateService.GetAllAsync();
+            return Ok(coordinates);
+        }
+
+        // GET: api/RentalEvidenceLACoordinate/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<RentalEvidenceLACoordinateResponseDto>> GetCoordinate(int id)
+        {
+            var coordinate = await _coordinateService.GetByIdAsync(id);
+
+            if (coordinate == null)
+            {
+                return NotFound($"Coordinate with ID {id} not found.");
+            }
+
+            return Ok(coordinate);
+        }
+
+        // GET: api/RentalEvidenceLACoordinate/rentalevidence/5
+        [HttpGet("rentalevidence/{rentalEvidenceId}")]
+        public async Task<ActionResult<IEnumerable<RentalEvidenceLACoordinateResponseDto>>> GetCoordinatesByRentalEvidenceId(int rentalEvidenceId)
+        {
+            var coordinates = await _coordinateService.GetByRentalEvidenceIdAsync(rentalEvidenceId);
+            return Ok(coordinates);
+        }
+
+        // GET: api/RentalEvidenceLACoordinate/masterfile/5
+        [HttpGet("masterfile/{masterfileId}")]
+        public async Task<ActionResult<IEnumerable<RentalEvidenceLACoordinateResponseDto>>> GetCoordinatesByMasterfileId(int masterfileId)
+        {
+            var coordinates = await _coordinateService.GetByMasterfileIdAsync(masterfileId);
+            return Ok(coordinates);
+        }
+
+        // POST: api/RentalEvidenceLACoordinate
+        [HttpPost]
+        public async Task<ActionResult<RentalEvidenceLACoordinateResponseDto>> CreateCoordinate(RentalEvidenceLACoordinateCreateDto dto)
+        {
+            try
+            {
+                var createdCoordinate = await _coordinateService.CreateAsync(dto);
+                return CreatedAtAction(nameof(GetCoordinate), new { id = createdCoordinate.Id }, createdCoordinate);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // PUT: api/RentalEvidenceLACoordinate/5
+        [HttpPut("{id}")]
+        public async Task<ActionResult<RentalEvidenceLACoordinateResponseDto>> UpdateCoordinate(int id, RentalEvidenceLACoordinateUpdateDto dto)
+        {
+            try
+            {
+                var updatedCoordinate = await _coordinateService.UpdateAsync(id, dto);
+                if (updatedCoordinate == null)
+                {
+                    return NotFound($"Coordinate with ID {id} not found.");
+                }
+
+                return Ok(updatedCoordinate);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (InvalidOperationException ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
+        }
+
+        // DELETE: api/RentalEvidenceLACoordinate/5
+        [HttpDelete("{id}")]
+        public async Task<ActionResult> DeleteCoordinate(int id)
+        {
+            var result = await _coordinateService.DeleteAsync(id);
+            if (!result)
+            {
+                return NotFound($"Coordinate with ID {id} not found.");
+            }
+
+            return NoContent();
+        }
+    }
+}
diff --git a/Controllers/LALotController.cs b/Controllers/LALotController.cs
new file mode 100644
index 0000000..8b74270
--- /dev/null
+++ b/Controllers/LALotController.cs
@@ -0,0 +1,102 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models.DTOs;
+using ValuationBackend.Services;
+
+namespace ValuationBackend.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class LALotController : ControllerBase
+    {
+        private readonly ILALotService _laLotService;
+
+        public LALotController(ILALotService laLotService)
+        {
+            _laLotService = laLotService;
+        }
+
+        // GET: api/LALot
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<LALotResponseDto>>> GetLALots()
+        {
+            var lots = await _laLotService.GetAllAsync();
+            return Ok(lots);
+        }
+
+        // GET: api/LALot/5
+        [HttpGet("{id}")]
+        public async Task<ActionResult<LALotResponseDto>> GetLALot(int id)
+        {
+            var laLot = await _laLotService.GetByIdAsync(id);
+
+            if (laLot == null)
+            {
+                return NotFound($"LALot with ID {id} not found.");
+            }
+
+            return Ok(laLot);
+        }
+
+        // GET: api/LALot/masterfile/5
+        [HttpGet("masterfile/{masterFileId}")]
+        public async Task<ActionResult<IEnumerable<LALotResponseDto>>> GetLALotsByMasterFileId(int masterFileId)
+        {
+            var lots = await _laLotService.GetByMasterFileIdAsync(masterFileId);
+            return Ok(lots);
+        }
+
+        // POST: api/LALot
+        [HttpPost]
+        public async Task<ActionResult<LALotResponseDto>> CreateLALot(LALotCreateDto dto)
+        {
+            try
+            {
+                var createdLALot = await _laLotService.CreateAsync(dto);
+                return CreatedAtAction(nameof(GetLALot), new { id = createdLALot.Id }, createdLALot);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+        }
+
+        // PUT: api/LALot/5
+        [HttpPut("{id}")]
+        public async Task<ActionResult<LALotResponseDto>> UpdateLALot(int id, LALotUpdateDto dto)
+        {
+            try
+            {
+                var updatedLALot = await _laLotService.UpdateAsync(id, dto);
+                if (updatedLALot == null)
+                {
+                    return NotFound($"LALot with ID {id} not found.");
+                }
+
+                return Ok(updatedLALot);
+            }
+            catch (ArgumentException ex)
+            {
+                return BadRequest(ex.Message);
+            }
+            catch (InvalidOperationException ex)
+            {
+                return StatusCode(500, ex.Message);
+            }
+        }
+
+        // DELETE: api/LALot/5
+        [HttpDelete("{id}")]
+        public async Task<ActionResult> DeleteLALot(int id)
+        {
+            var result = await _laLotService.DeleteAsync(id);
+            if (!result)
+            {
+                return NotFound($"LALot with ID {id} not found.");
+            }
+
+            return NoContent();
+        }
+    }
+}
diff --git a/Controllers/LMBuildingRatesController.cs b/Controllers/LMBuildingRatesController.cs
index 597426f..7d03416 100644
--- a/Controllers/LMBuildingRatesController.cs
+++ b/Controllers/LMBuildingRatesController.cs
@@ -81,5 +81,13 @@ public async Task<ActionResult<LMBuildingRatesResponseDto>> GetLMBuildingRateByR
 
             return lmBuildingRate;
         }
+
+        // GET: api/LMBuildingRates/ByMasterFile/5
+        [HttpGet("ByMasterFile/{masterFileId}")]
+        public async Task<ActionResult<IEnumerable<LMBuildingRatesResponseDto>>> GetLMBuildingRatesByMasterFileId(int masterFileId)
+        {
+            var buildingRates = await _lmBuildingRatesService.GetByMasterFileIdAsync(masterFileId);
+            return Ok(buildingRates);
+        }
     }
 }
diff --git a/Controllers/LMPastValuationController.cs b/Controllers/LMPastValuationController.cs
index 5059497..921271e 100644
--- a/Controllers/LMPastValuationController.cs
+++ b/Controllers/LMPastValuationController.cs
@@ -93,5 +93,13 @@ public async Task<ActionResult<LMPastValuationResponseDto>> GetLMPastValuationBy
 
             return lmPastValuation;
         }
+
+        // GET: api/LMPastValuation/ByMasterFile/5
+        [HttpGet("ByMasterFile/{masterFileId}")]
+        public async Task<ActionResult<IEnumerable<LMPastValuationResponseDto>>> GetLMPastValuationsByMasterFileId(int masterFileId)
+        {
+            var pastValuations = await _lmPastValuationService.GetByMasterFileIdAsync(masterFileId);
+            return Ok(pastValuations);
+        }
     }
 }
diff --git a/Controllers/LMRentalEvidenceController.cs b/Controllers/LMRentalEvidenceController.cs
index ab60c3d..e0aa5b6 100644
--- a/Controllers/LMRentalEvidenceController.cs
+++ b/Controllers/LMRentalEvidenceController.cs
@@ -93,5 +93,29 @@ public async Task<ActionResult<LMRentalEvidenceResponseDto>> GetLMRentalEvidence
 
             return lmRentalEvidence;
         }
+
+        // NEW: GET: api/LMRentalEvidence/ByMasterFile/123
+        [HttpGet("ByMasterFile/{masterFileId}")]
+        public async Task<ActionResult<IEnumerable<LMRentalEvidenceResponseDto>>> GetByMasterFileId(int masterFileId)
+        {
+            var evidences = await _lmRentalEvidenceService.GetByMasterFileIdAsync(masterFileId);
+            return Ok(evidences);
+        }
+
+        // NEW: GET: api/LMRentalEvidence/ByMasterFileRefNo/MF-2024-001
+        [HttpGet("ByMasterFileRefNo/{masterFileRefNo}")]
+        public async Task<ActionResult<IEnumerable<LMRentalEvidenceResponseDto>>> GetByMasterFileRefNo(string masterFileRefNo)
+        {
+            var evidences = await _lmRentalEvidenceService.GetByMasterFileRefNoAsync(masterFileRefNo);
+            return Ok(evidences);
+        }
+
+        // NEW: GET: api/LMRentalEvidence/WithMasterFileData
+        [HttpGet("WithMasterFileData")]
+        public async Task<ActionResult<IEnumerable<LMRentalEvidenceResponseDto>>> GetAllWithMasterFileData()
+        {
+            var evidences = await _lmRentalEvidenceService.GetAllWithMasterFileDataAsync();
+            return Ok(evidences);
+        }
     }
 }
diff --git a/Controllers/LMSalesEvidenceController.cs b/Controllers/LMSalesEvidenceController.cs
index 3f357e5..db1a456 100644
--- a/Controllers/LMSalesEvidenceController.cs
+++ b/Controllers/LMSalesEvidenceController.cs
@@ -93,5 +93,13 @@ public async Task<ActionResult<LMSalesEvidenceResponseDto>> GetLMSalesEvidenceBy
 
             return lmSalesEvidence;
         }
+
+        // GET: api/LMSalesEvidence/ByMasterFile/5
+        [HttpGet("ByMasterFile/{masterFileId}")]
+        public async Task<ActionResult<IEnumerable<LMSalesEvidenceResponseDto>>> GetLMSalesEvidencesByMasterFileId(int masterFileId)
+        {
+            var salesEvidences = await _lmSalesEvidenceService.GetByMasterFileIdAsync(masterFileId);
+            return Ok(salesEvidences);
+        }
     }
 }
diff --git a/Controllers/iteration2/DecisionFieldController.cs b/Controllers/iteration2/DecisionFieldController.cs
new file mode 100644
index 0000000..acef1d2
--- /dev/null
+++ b/Controllers/iteration2/DecisionFieldController.cs
@@ -0,0 +1,36 @@
+using Microsoft.AspNetCore.Mvc;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models.DTOs;
+using ValuationBackend.Services;
+using ValuationBackend.Data;
+using ValuationBackend.Models;      
+using Microsoft.EntityFrameworkCore;
+
+
+[ApiController]
+[Route("api/decision-fields")]
+public class DecisionFieldController : ControllerBase
+{
+    private readonly ValuationContext _context;
+
+    public DecisionFieldController(ValuationContext context)
+    {
+        _context = context;
+    }
+
+    [HttpPost]
+    public async Task<IActionResult> CreateField([FromBody] DecisionField field)
+    {
+        _context.DecisionFields.Add(field);
+        await _context.SaveChangesAsync();
+        return Ok(field);
+    }
+
+    [HttpGet]
+    public async Task<IActionResult> GetAllFields()
+    {
+        var fields = await _context.DecisionFields.ToListAsync();
+        return Ok(fields);
+    }
+}
diff --git a/Controllers/iteration2/RatingFileController.cs b/Controllers/iteration2/RatingFileController.cs
new file mode 100644
index 0000000..0123ea2
--- /dev/null
+++ b/Controllers/iteration2/RatingFileController.cs
@@ -0,0 +1,34 @@
+using Microsoft.AspNetCore.Mvc;
+
+[ApiController]
+[Route("api/{requestType}/ratingfile")]
+public class RatingFileController : ControllerBase
+{
+    // 1. Load all street names
+    [HttpGet("streets")]
+    public IActionResult GetStreets(string requestType)
+    {
+        var streets = new[]
+        {
+            new { id = "S1", name = "Main Street" },
+            new { id = "S2", name = "Highway Road" },
+            new { id = "S3", name = "Park Avenue" }
+        };
+
+        return Ok(new { streets });
+    }
+
+    // 2. Load obsolete numbers for selected street
+    [HttpGet("streets/{streetId}/obsolete-numbers")]
+    public IActionResult GetObsoleteNumbers(string requestType, string streetId)
+    {
+        var obsoleteNumbers = new[]
+        {
+            new { id = "O1", number = "101" },
+            new { id = "O2", number = "102" },
+            new { id = "O3", number = "103" }
+        };
+
+        return Ok(new { obsoleteNumbers });
+    }
+}
diff --git a/Data/AppDbContext.cs b/Data/AppDbContext.cs
index 0d3333e..59b1288 100644
--- a/Data/AppDbContext.cs
+++ b/Data/AppDbContext.cs
@@ -10,7 +10,7 @@ public AppDbContext(DbContextOptions<AppDbContext> options)
             : base(options) { }
 
         public DbSet<RatingRequest> RatingRequests { get; set; }
-        
+
         public DbSet<LandMiscellaneousMasterFile> LandMiscellaneousMasterFiles { get; set; }
 
         public DbSet<Reconciliation> Reconciliations { get; set; }
@@ -29,6 +29,13 @@ public AppDbContext(DbContextOptions<AppDbContext> options)
 
         public DbSet<LandAquisitionMasterFile> LandAquisitionMasterFiles { get; set; }
 
+        public DbSet<LALot> LALots { get; set; }
+
+        public DbSet<PastValuationsLACoordinate> PastValuationsLACoordinates { get; set; }
+        public DbSet<BuildingRatesLACoordinate> BuildingRatesLACoordinates { get; set; }
+        public DbSet<SalesEvidenceLACoordinate> SalesEvidenceLACoordinates { get; set; }
+        public DbSet<RentalEvidenceLACoordinate> RentalEvidenceLACoordinates { get; set; }
+
         public DbSet<Report> Reports { get; set; }
 
         public DbSet<InspectionReport> InspectionReports { get; set; }
@@ -68,6 +75,10 @@ public AppDbContext(DbContextOptions<AppDbContext> options)
 
         public DbSet<PropertyCategory> PropertyCategories { get; set; }
 
+
+        public DbSet<DecisionField> DecisionFields { get; set; }
+        public DbSet<PasswordReset> PasswordResets { get; set; }
+
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             base.OnModelCreating(modelBuilder);
@@ -79,6 +90,51 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
     .HasOne(r => r.Asset)
     .WithMany()
     .HasForeignKey(r => r.AssetId);
+
+            // NEW: Configure LMRentalEvidence relationships
+            modelBuilder.Entity<LMRentalEvidence>()
+                .HasOne(lm => lm.LandMiscellaneousMasterFile)
+                .WithMany()
+                .HasForeignKey(lm => lm.LandMiscellaneousMasterFileId)
+                .OnDelete(DeleteBehavior.SetNull);
+
+            // NEW: Add index for performance
+            modelBuilder.Entity<LMRentalEvidence>()
+                .HasIndex(lm => lm.LandMiscellaneousMasterFileId)
+                .HasDatabaseName("IX_LMRentalEvidence_LandMiscellaneousMasterFileId");
+
+            // Configure LMBuildingRates relationships
+            modelBuilder.Entity<LMBuildingRates>()
+                .HasOne(lm => lm.LandMiscellaneousMasterFile)
+                .WithMany() // No navigation property on master file side
+                .HasForeignKey(lm => lm.LandMiscellaneousMasterFileId)
+                .OnDelete(DeleteBehavior.SetNull);
+
+            modelBuilder.Entity<LMBuildingRates>()
+                .HasIndex(lm => lm.LandMiscellaneousMasterFileId)
+                .HasDatabaseName("IX_LMBuildingRates_LandMiscellaneousMasterFileId");
+
+            // Configure LMPastValuation relationships
+            modelBuilder.Entity<LMPastValuation>()
+                .HasOne(lm => lm.LandMiscellaneousMasterFile)
+                .WithMany() // No navigation property on master file side
+                .HasForeignKey(lm => lm.LandMiscellaneousMasterFileId)
+                .OnDelete(DeleteBehavior.SetNull);
+
+            modelBuilder.Entity<LMPastValuation>()
+                .HasIndex(lm => lm.LandMiscellaneousMasterFileId)
+                .HasDatabaseName("IX_LMPastValuation_LandMiscellaneousMasterFileId");
+
+            // Configure LMSalesEvidence relationships
+            modelBuilder.Entity<LMSalesEvidence>()
+                .HasOne(lm => lm.LandMiscellaneousMasterFile)
+                .WithMany() // No navigation property on master file side
+                .HasForeignKey(lm => lm.LandMiscellaneousMasterFileId)
+                .OnDelete(DeleteBehavior.SetNull);
+
+            modelBuilder.Entity<LMSalesEvidence>()
+                .HasIndex(lm => lm.LandMiscellaneousMasterFileId)
+                .HasDatabaseName("IX_LMSalesEvidence_LandMiscellaneousMasterFileId");
         }
     }
 }
diff --git a/Data/DBInitializer.cs b/Data/DBInitializer.cs
index 5716f1d..2a85663 100644
--- a/Data/DBInitializer.cs
+++ b/Data/DBInitializer.cs
@@ -1,6 +1,7 @@
 using System.Security.Cryptography;
 using System.Text;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
 using ValuationBackend.Models;
 
 namespace ValuationBackend.Data
@@ -31,7 +32,7 @@ public static void Initialize(AppDbContext context)
                 // Update UserTasks with correct User IDs
                 UpdateUserTaskUserIds(context);
 
-                // Remove UserTasks that are not LM (Land Miscellaneous)
+                // Remove UserTasks that are not LM (Land Miscellaneous) - COMMENTED OUT to keep LA and MR tasks
                 // RemoveNonLMUserTasks(context);
 
                 // Initialize Master Data
@@ -1136,18 +1137,31 @@ string division
 
         private static void InitializeUserTasks(AppDbContext context)
         {
-            // Calculate expected task count: 12 LA tasks + number of LM records
-            var expectedTaskCount = 12 + context.LandMiscellaneousMasterFiles.Count();
+            // Calculate expected task count: 12 LA/MR tasks + number of LM records  
+            var expectedLmTaskCount = context.LandMiscellaneousMasterFiles.Count();
+            var expectedNonLmTaskCount = 12;
+            var currentLmTaskCount = context.UserTasks.Count(t => t.TaskType == "LM");
+            var currentNonLmTaskCount = context.UserTasks.Count(t => t.TaskType != "LM");
+
+            // Check if we have sufficient LM tasks - only reseed LM tasks if needed
+            bool needLmTasks = currentLmTaskCount < expectedLmTaskCount;
+            bool needNonLmTasks = currentNonLmTaskCount < expectedNonLmTaskCount;
 
-            // Check if we already have enough tasks
-            if (context.UserTasks.Count() >= expectedTaskCount)
+            if (!needLmTasks && !needNonLmTasks)
                 return;
 
-            // Remove all existing user tasks to ensure clean seeding
-            if (context.UserTasks.Any())
+            // Only remove non-LM tasks if we need to reseed them
+            if (needNonLmTasks && currentNonLmTaskCount > 0)
             {
-                context.UserTasks.RemoveRange(context.UserTasks);
+                var nonLmTasks = context.UserTasks.Where(t => t.TaskType != "LM").ToList();
+                Console.WriteLine($"Removing {nonLmTasks.Count} UserTask entries with TaskType other than 'LM'...");
+                foreach (var task in nonLmTasks)
+                {
+                    Console.WriteLine($"Removing UserTask: Username={task.Username}, TaskType={task.TaskType}, Description={task.WorkItemDescription}");
+                }
+                context.UserTasks.RemoveRange(nonLmTasks);
                 context.SaveChanges();
+                Console.WriteLine("Non-LM UserTasks removed successfully.");
             }
 
             Console.WriteLine("Seeding user tasks...");
@@ -1188,57 +1202,92 @@ void AddTask(string username, string type, bool completed, string date,
                 );
             }
 
-            // Non-LM tasks (LA and MR tasks without referencing old LandMiscellaneous IDs)
-            // Jalina's tasks
-            AddTask("Jalina", "LA", true, "20250105", landAcquisitionId: 1, description: "Land acquisition survey for Highway Project", referenceNumber: "LA-2025-001");
-            AddTask("Jalina", "MR", true, "20250115", requestId: 1, description: "Mass rating assessment - Colombo MC", referenceNumber: "MR-2025-001");
-            AddTask("Jalina", "LA", true, "20250301", landAcquisitionId: 2, description: "Land acquisition for Bridge Project", referenceNumber: "LA-2025-002");
-
-            // Akith's tasks
-            AddTask("Akith", "MR", true, "20250120", requestId: 2, description: "Rating assessment - Galle MC", referenceNumber: "MR-2025-002");
-            AddTask("Akith", "LA", false, "20250225", landAcquisitionId: 3, description: "Land acquisition survey", referenceNumber: "LA-2025-003");
-
-            // Dulmini's tasks
-            AddTask("Dulmini", "LA", true, "20250110", landAcquisitionId: 4, description: "Land acquisition documentation", referenceNumber: "LA-2025-004");
-            AddTask("Dulmini", "MR", true, "20250112", requestId: 3, description: "Rating building assessment", referenceNumber: "MR-2025-003");
-            AddTask("Dulmini", "MR", false, "20250302", requestId: 1, description: "Follow-up rating assessment", referenceNumber: "MR-2025-004");
-
-            // Vishwa's tasks
-            AddTask("Vishwa", "LA", true, "20250101", landAcquisitionId: 5, description: "Land acquisition initial survey", referenceNumber: "LA-2025-005");
-            AddTask("Vishwa", "LA", true, "20250215", landAcquisitionId: 6, description: "Land acquisition follow-up", referenceNumber: "LA-2025-006");
-            AddTask("Vishwa", "MR", true, "20250318", requestId: 2, description: "Additional rating assessment", referenceNumber: "MR-2025-005");
-
-            // Rithara's tasks
-            AddTask("Rithara", "MR", true, "20250118", requestId: 3, description: "Building rating review", referenceNumber: "MR-2025-006");
-            AddTask("Rithara", "LA", false, "20250311", landAcquisitionId: 7, description: "Land acquisition assessment", referenceNumber: "LA-2025-007");
-
-            // LM tasks for all current land miscellaneous records - randomly distributed
-            var users = new[] { "Jalina", "Akith", "Dulmini", "Vishwa", "Rithara" };
-            var planTypes = new[] { "PP", "Cadaster", "FVP" };
-            var random = new Random(42); // Fixed seed for consistent results
-
-            // Get all actual LandMiscellaneous records from database to use their real IDs
-            var landMiscRecords = context.LandMiscellaneousMasterFiles.OrderBy(lm => lm.MasterFileNo).ToList();
+            // Add non-LM tasks only if needed
+            if (needNonLmTasks)
+            {
+                // Non-LM tasks (LA and MR tasks without referencing old LandMiscellaneous IDs)
+                // Jalina's tasks
+                AddTask("Jalina", "LA", true, "20250105", landAcquisitionId: 1, description: "Land acquisition survey for Highway Project", referenceNumber: "LA-2025-001");
+                AddTask("Jalina", "MR", true, "20250115", requestId: 1, description: "Mass rating assessment - Colombo MC", referenceNumber: "MR-2025-001");
+                AddTask("Jalina", "LA", true, "20250301", landAcquisitionId: 2, description: "Land acquisition for Bridge Project", referenceNumber: "LA-2025-002");
+
+                // Akith's tasks
+                AddTask("Akith", "MR", true, "20250120", requestId: 2, description: "Rating assessment - Galle MC", referenceNumber: "MR-2025-002");
+                AddTask("Akith", "LA", false, "20250225", landAcquisitionId: 3, description: "Land acquisition survey", referenceNumber: "LA-2025-003");
+
+                // Dulmini's tasks
+                AddTask("Dulmini", "LA", true, "20250110", landAcquisitionId: 4, description: "Land acquisition documentation", referenceNumber: "LA-2025-004");
+                AddTask("Dulmini", "MR", true, "20250112", requestId: 3, description: "Rating building assessment", referenceNumber: "MR-2025-003");
+                AddTask("Dulmini", "MR", false, "20250302", requestId: 1, description: "Follow-up rating assessment", referenceNumber: "MR-2025-004");
+
+                // Vishwa's tasks
+                AddTask("Vishwa", "LA", true, "20250101", landAcquisitionId: 5, description: "Land acquisition initial survey", referenceNumber: "LA-2025-005");
+                AddTask("Vishwa", "LA", true, "20250215", landAcquisitionId: 6, description: "Land acquisition follow-up", referenceNumber: "LA-2025-006");
+                AddTask("Vishwa", "MR", true, "20250318", requestId: 2, description: "Additional rating assessment", referenceNumber: "MR-2025-005");
+
+                // Rithara's tasks
+                AddTask("Rithara", "MR", true, "20250118", requestId: 3, description: "Building rating review", referenceNumber: "MR-2025-006");
+                AddTask("Rithara", "LA", false, "20250311", landAcquisitionId: 7, description: "Land acquisition assessment", referenceNumber: "LA-2025-007");
+
+                // Additional LA tasks for remaining Land Acquisition Master Files (IDs 8-22)
+                // Distribute among all 5 users
+                AddTask("Jalina", "LA", true, "20250315", landAcquisitionId: 8, description: "Land acquisition survey for Metro Line", referenceNumber: "LA-2025-008");
+                AddTask("Akith", "LA", false, "20250320", landAcquisitionId: 9, description: "Land acquisition for School Development", referenceNumber: "LA-2025-009");
+                AddTask("Dulmini", "LA", true, "20250325", landAcquisitionId: 10, description: "Land acquisition documentation review", referenceNumber: "LA-2025-010");
+                AddTask("Vishwa", "LA", false, "20250330", landAcquisitionId: 11, description: "Land acquisition field verification", referenceNumber: "LA-2025-011");
+                AddTask("Rithara", "LA", true, "20250405", landAcquisitionId: 12, description: "Land acquisition boundary survey", referenceNumber: "LA-2025-012");
+
+                AddTask("Jalina", "LA", false, "20250410", landAcquisitionId: 13, description: "Land acquisition for Hospital Extension", referenceNumber: "LA-2025-013");
+                AddTask("Akith", "LA", true, "20250415", landAcquisitionId: 14, description: "Land acquisition compensation assessment", referenceNumber: "LA-2025-014");
+                AddTask("Dulmini", "LA", false, "20250420", landAcquisitionId: 15, description: "Land acquisition legal documentation", referenceNumber: "LA-2025-015");
+                AddTask("Vishwa", "LA", true, "20250425", landAcquisitionId: 16, description: "Land acquisition site inspection", referenceNumber: "LA-2025-016");
+                AddTask("Rithara", "LA", false, "20250430", landAcquisitionId: 17, description: "Land acquisition valuation report", referenceNumber: "LA-2025-017");
+
+                AddTask("Jalina", "LA", true, "20250505", landAcquisitionId: 18, description: "Land acquisition for Road Widening", referenceNumber: "LA-2025-018");
+                AddTask("Akith", "LA", false, "20250510", landAcquisitionId: 19, description: "Land acquisition preliminary survey", referenceNumber: "LA-2025-019");
+                AddTask("Dulmini", "LA", true, "20250515", landAcquisitionId: 20, description: "Land acquisition title verification", referenceNumber: "LA-2025-020");
+                AddTask("Vishwa", "LA", false, "20250520", landAcquisitionId: 21, description: "Land acquisition environmental assessment", referenceNumber: "LA-2025-021");
+                AddTask("Rithara", "LA", true, "20250525", landAcquisitionId: 22, description: "Land acquisition final documentation", referenceNumber: "LA-2025-022");
+            }
 
-            // Create tasks for each actual LandMiscellaneous record
-            for (int i = 0; i < landMiscRecords.Count; i++)
+            // Add LM tasks only if needed
+            if (needLmTasks)
             {
-                var record = landMiscRecords[i];
-                var randomUser = users[random.Next(users.Length)];
-                var randomPlanType = planTypes[random.Next(planTypes.Length)];
-                var isCompleted = random.Next(100) < 30; // 30% chance of being completed
-                var randomDays = random.Next(1, 120); // Random date within last 120 days
-                var assignedDate = DateTime.Today.AddDays(-randomDays).ToString("yyyyMMdd");
-
-                AddTask(randomUser, "LM", isCompleted, assignedDate,
-                    landMiscellaneousId: record.Id, // Use the actual database ID
-                    description: $"{randomPlanType} plan verification for {record.MasterFileNo}",
-                    referenceNumber: $"LM-2025-{(i + 1):D3}");
+                // LM tasks for all current land miscellaneous records - randomly distributed
+                var users = new[] { "Jalina", "Akith", "Dulmini", "Vishwa", "Rithara" };
+                var planTypes = new[] { "PP", "Cadaster", "FVP" };
+                var random = new Random(42); // Fixed seed for consistent results
+
+                // Get all actual LandMiscellaneous records from database to use their real IDs
+                var landMiscRecords = context.LandMiscellaneousMasterFiles.OrderBy(lm => lm.MasterFileNo).ToList();
+
+                // Create tasks for each actual LandMiscellaneous record
+                for (int i = 0; i < landMiscRecords.Count; i++)
+                {
+                    var record = landMiscRecords[i];
+                    var randomUser = users[random.Next(users.Length)];
+                    var randomPlanType = planTypes[random.Next(planTypes.Length)];
+                    var isCompleted = random.Next(100) < 30; // 30% chance of being completed
+                    var randomDays = random.Next(1, 120); // Random date within last 120 days
+                    var assignedDate = DateTime.Today.AddDays(-randomDays).ToString("yyyyMMdd");
+
+                    AddTask(randomUser, "LM", isCompleted, assignedDate,
+                        landMiscellaneousId: record.Id, // Use the actual database ID
+                        description: $"{randomPlanType} plan verification for {record.MasterFileNo}",
+                        referenceNumber: $"LM-2025-{(i + 1):D3}");
+                }
             }
 
-            context.UserTasks.AddRange(tasks);
-            context.SaveChanges();
-            Console.WriteLine("User tasks seeded.");
+            if (tasks.Any())
+            {
+                context.UserTasks.AddRange(tasks);
+                context.SaveChanges();
+                Console.WriteLine($"User tasks seeded. Added {tasks.Count} tasks (LM: {tasks.Count(t => t.TaskType == "LM")}, Non-LM: {tasks.Count(t => t.TaskType != "LM")}).");
+            }
+            else
+            {
+                Console.WriteLine("No new tasks needed - all UserTasks are already properly seeded.");
+            }
         }
 
         private static void UpdateUserTaskAssignments(AppDbContext context)
@@ -1483,12 +1532,9 @@ private static void InitializeRequestTypes(AppDbContext context)
 
         private static void InitializeRequests(AppDbContext context)
         {
-            // Clear existing data to allow reseeding
+            // Only seed if no requests exist
             if (context.Requests.Any())
-            {
-                context.Requests.RemoveRange(context.Requests);
-                context.SaveChanges();
-            }
+                return;
 
             Console.WriteLine("Seeding requests...");
 
@@ -1664,12 +1710,9 @@ private static void InitializeRequests(AppDbContext context)
 
         private static void InitializeAssets(AppDbContext context)
         {
-            // Clear existing data to allow reseeding
+            // Only seed if no assets exist
             if (context.Assets.Any())
-            {
-                context.Assets.RemoveRange(context.Assets);
-                context.SaveChanges();
-            }
+                return;
 
             Console.WriteLine("Seeding assets...");
 
@@ -1913,5 +1956,7 @@ private static void InitializeReconciliations(AppDbContext context)
             context.SaveChanges();
             Console.WriteLine("Reconciliations seeded.");
         }
+        
+        
     }
 }
diff --git a/Data/PopulateForeignKeysMigration.cs b/Data/PopulateForeignKeysMigration.cs
new file mode 100644
index 0000000..a722272
--- /dev/null
+++ b/Data/PopulateForeignKeysMigration.cs
@@ -0,0 +1,99 @@
+using Microsoft.EntityFrameworkCore;
+using ValuationBackend.Models;
+
+namespace ValuationBackend.Data
+{
+    public static class PopulateForeignKeysMigration
+    {
+        /// <summary>
+        /// Populates the LandMiscellaneousMasterFileId foreign key in LMRentalEvidence 
+        /// based on existing MasterFileRefNo values
+        /// </summary>
+        public static async Task PopulateLMRentalEvidenceForeignKeys(AppDbContext context)
+        {
+            // Get all rental evidences where foreign key is null but string reference exists
+            var rentalEvidences = await context.LMRentalEvidences
+                .Where(re => re.LandMiscellaneousMasterFileId == null &&
+                            !string.IsNullOrEmpty(re.MasterFileRefNo))
+                .ToListAsync();
+
+            if (!rentalEvidences.Any())
+            {
+                Console.WriteLine("No rental evidences found that need foreign key population.");
+                return;
+            }
+
+            Console.WriteLine($"Found {rentalEvidences.Count} rental evidences to update.");
+
+            int updatedCount = 0;
+            int skippedCount = 0;
+
+            foreach (var evidence in rentalEvidences)
+            {
+                // Find the corresponding master file
+                var masterFile = await context.LandMiscellaneousMasterFiles
+                    .FirstOrDefaultAsync(mf => mf.MasterFileRefNo == evidence.MasterFileRefNo);
+
+                if (masterFile != null)
+                {
+                    evidence.LandMiscellaneousMasterFileId = masterFile.Id;
+                    updatedCount++;
+                    Console.WriteLine($"Updated rental evidence ID {evidence.Id} with master file ID {masterFile.Id}");
+                }
+                else
+                {
+                    skippedCount++;
+                    Console.WriteLine($"Warning: No master file found for reference number '{evidence.MasterFileRefNo}' (Rental Evidence ID: {evidence.Id})");
+                }
+            }
+
+            if (updatedCount > 0)
+            {
+                await context.SaveChangesAsync();
+                Console.WriteLine($"Successfully updated {updatedCount} rental evidence records.");
+            }
+
+            if (skippedCount > 0)
+            {
+                Console.WriteLine($"Skipped {skippedCount} records due to missing master file references.");
+            }
+        }
+
+        /// <summary>
+        /// Validates the foreign key relationships after population
+        /// </summary>
+        public static async Task ValidateForeignKeyRelationships(AppDbContext context)
+        {
+            // Check for rental evidences with valid foreign keys
+            var withForeignKeys = await context.LMRentalEvidences
+                .CountAsync(re => re.LandMiscellaneousMasterFileId.HasValue);
+
+            // Check for rental evidences without foreign keys but with string references
+            var withoutForeignKeys = await context.LMRentalEvidences
+                .CountAsync(re => !re.LandMiscellaneousMasterFileId.HasValue &&
+                                 !string.IsNullOrEmpty(re.MasterFileRefNo));
+
+            // Check for orphaned references (string references that don't match any master file)
+            var orphanedReferences = await context.LMRentalEvidences
+                .Where(re => !string.IsNullOrEmpty(re.MasterFileRefNo))
+                .Where(re => !context.LandMiscellaneousMasterFiles
+                    .Any(mf => mf.MasterFileRefNo == re.MasterFileRefNo))
+                .CountAsync();
+
+            Console.WriteLine("=== Foreign Key Relationship Validation ===");
+            Console.WriteLine($"Rental evidences with foreign keys: {withForeignKeys}");
+            Console.WriteLine($"Rental evidences without foreign keys (but with string refs): {withoutForeignKeys}");
+            Console.WriteLine($"Orphaned string references: {orphanedReferences}");
+
+            if (withoutForeignKeys > 0)
+            {
+                Console.WriteLine("Warning: Some rental evidences still lack foreign key relationships.");
+            }
+
+            if (orphanedReferences > 0)
+            {
+                Console.WriteLine("Warning: Some rental evidences reference master files that don't exist.");
+            }
+        }
+    }
+}
diff --git a/Data/ValuationContext.cs b/Data/ValuationContext.cs
new file mode 100644
index 0000000..5554fb4
--- /dev/null
+++ b/Data/ValuationContext.cs
@@ -0,0 +1,13 @@
+using Microsoft.EntityFrameworkCore;
+using ValuationBackend.Models;
+
+namespace ValuationBackend.Data
+{
+    public class ValuationContext : DbContext
+    {
+        public ValuationContext(DbContextOptions<ValuationContext> options) : base(options) { }
+
+        public DbSet<DecisionField> DecisionFields { get; set; }
+        // ...add other DbSets as needed...
+    }
+}
diff --git a/Extensions/RepositoryExtensions.cs b/Extensions/RepositoryExtensions.cs
index 65b4650..4adf22a 100644
--- a/Extensions/RepositoryExtensions.cs
+++ b/Extensions/RepositoryExtensions.cs
@@ -25,6 +25,11 @@ public static IServiceCollection AddRepositories(this IServiceCollection service
             services.AddScoped<IDomesticRatingCardRepository, DomesticRatingCardRepository>();
             services.AddScoped<IOfficesRatingCardRepository, OfficesRatingCardRepository>();
             services.AddScoped<ILAMasterfileRepository, LAMasterfileRepository>();
+            services.AddScoped<ILALotRepository, LALotRepository>();
+            services.AddScoped<IPastValuationsLACoordinateRepository, PastValuationsLACoordinateRepository>();
+            services.AddScoped<IBuildingRatesLACoordinateRepository, BuildingRatesLACoordinateRepository>();
+            services.AddScoped<ISalesEvidenceLACoordinateRepository, SalesEvidenceLACoordinateRepository>();
+            services.AddScoped<IRentalEvidenceLACoordinateRepository, RentalEvidenceLACoordinateRepository>();
             services.AddScoped<IRequestTypeRepository, RequestTypeRepository>();
             services.AddScoped<IRequestRepository, RequestRepository>();
             services.AddScoped<IAssetRepository, AssetRepository>();
diff --git a/Extensions/ServiceExtensions.cs b/Extensions/ServiceExtensions.cs
index 014aa52..3fdccd8 100644
--- a/Extensions/ServiceExtensions.cs
+++ b/Extensions/ServiceExtensions.cs
@@ -15,6 +15,7 @@ public static IServiceCollection AddServices(this IServiceCollection services)
             services.AddScoped<IInspectionReportService, InspectionReportService>();
             services.AddScoped<ILandMiscellaneousService, LandMiscellaneousService>();
             services.AddScoped<ILMBuildingRatesService, LMBuildingRatesService>();
+            services.AddScoped<ILMPastValuationService, LMPastValuationService>();
             services.AddScoped<IDomesticRatingCardService, DomesticRatingCardService>();
             services.AddScoped<IOfficesRatingCardService, OfficesRatingCardService>();
             services.AddScoped<ILMRentalEvidenceService, LMRentalEvidenceService>();
@@ -24,6 +25,11 @@ public static IServiceCollection AddServices(this IServiceCollection services)
             services.AddScoped<IAssetDivisionService, AssetDivisionService>();
             services.AddScoped<IReconciliationService, ReconciliationService>();
             services.AddScoped<ILAMasterfileService, LAMasterfileService>();
+            services.AddScoped<ILALotService, LALotService>();
+            services.AddScoped<IPastValuationsLACoordinateService, PastValuationsLACoordinateService>();
+            services.AddScoped<IBuildingRatesLACoordinateService, BuildingRatesLACoordinateService>();
+            services.AddScoped<ISalesEvidenceLACoordinateService, SalesEvidenceLACoordinateService>();
+            services.AddScoped<IRentalEvidenceLACoordinateService, RentalEvidenceLACoordinateService>();
             services.AddScoped<IRequestTypeService, RequestTypeService>();
             services.AddScoped<IRequestService, RequestService>();
             services.AddScoped<IAssetService, AssetService>();
diff --git a/Migrations/20250428193956_InitialCreate.cs b/Migrations/20250428193956_InitialCreate.cs
index 5ce4d63..8d21868 100644
--- a/Migrations/20250428193956_InitialCreate.cs
+++ b/Migrations/20250428193956_InitialCreate.cs
@@ -27,6 +27,22 @@ protected override void Up(MigrationBuilder migrationBuilder)
                 {
                     table.PrimaryKey("PK_RatingRequests", x => x.Id);
                 });
+
+            migrationBuilder.CreateTable(
+                name: "PasswordResets",
+                columns: table => new
+                {
+                    Id = table.Column<int>(nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Email = table.Column<string>(nullable: false),
+                    Otp = table.Column<string>(nullable: false),
+                    ExpiresAt = table.Column<DateTime>(nullable: false),
+                    Used = table.Column<bool>(nullable: false, defaultValue: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PasswordResets", x => x.Id);
+                });
         }
 
         /// <inheritdoc />
diff --git a/Migrations/20250720064824_AddMasterFileRefNoToLandMiscellaneousMasterFile.Designer.cs b/Migrations/20250720064824_AddMasterFileRefNoToLandMiscellaneousMasterFile.Designer.cs
new file mode 100644
index 0000000..608699d
--- /dev/null
+++ b/Migrations/20250720064824_AddMasterFileRefNoToLandMiscellaneousMasterFile.Designer.cs
@@ -0,0 +1,1714 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250720064824_AddMasterFileRefNoToLandMiscellaneousMasterFile")]
+    partial class AddMasterFileRefNoToLandMiscellaneousMasterFile
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250720064824_AddMasterFileRefNoToLandMiscellaneousMasterFile.cs b/Migrations/20250720064824_AddMasterFileRefNoToLandMiscellaneousMasterFile.cs
new file mode 100644
index 0000000..10e34eb
--- /dev/null
+++ b/Migrations/20250720064824_AddMasterFileRefNoToLandMiscellaneousMasterFile.cs
@@ -0,0 +1,35 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddMasterFileRefNoToLandMiscellaneousMasterFile : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "MasterFileRefNo",
+                table: "LandMiscellaneousMasterFiles",
+                type: "text",
+                nullable: true);
+
+            // Update existing records with MasterFileRefNo based on MasterFileNo
+            migrationBuilder.Sql(@"
+                UPDATE ""LandMiscellaneousMasterFiles"" 
+                SET ""MasterFileRefNo"" = 'Metro 2/LA/' || ""MasterFileNo""
+                WHERE ""MasterFileRefNo"" IS NULL;
+            ");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "MasterFileRefNo",
+                table: "LandMiscellaneousMasterFiles");
+        }
+    }
+}
diff --git a/Migrations/20250721174110_AddPasswordResetTable.Designer.cs b/Migrations/20250721174110_AddPasswordResetTable.Designer.cs
new file mode 100644
index 0000000..46b5169
--- /dev/null
+++ b/Migrations/20250721174110_AddPasswordResetTable.Designer.cs
@@ -0,0 +1,1919 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250721174110_AddPasswordResetTable")]
+    partial class AddPasswordResetTable
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250721174110_AddPasswordResetTable.cs b/Migrations/20250721174110_AddPasswordResetTable.cs
new file mode 100644
index 0000000..7025b37
--- /dev/null
+++ b/Migrations/20250721174110_AddPasswordResetTable.cs
@@ -0,0 +1,39 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPasswordResetTable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "PasswordResets",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    Email = table.Column<string>(type: "text", nullable: false),
+                    Otp = table.Column<string>(type: "text", nullable: false),
+                    ExpiresAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    Used = table.Column<bool>(type: "boolean", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PasswordResets", x => x.Id);
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "PasswordResets");
+        }
+    }
+}
diff --git a/Migrations/20250722032612_AddLandMiscellaneousMasterFileIdToLMRentalEvidence.Designer.cs b/Migrations/20250722032612_AddLandMiscellaneousMasterFileIdToLMRentalEvidence.Designer.cs
new file mode 100644
index 0000000..9593b8d
--- /dev/null
+++ b/Migrations/20250722032612_AddLandMiscellaneousMasterFileIdToLMRentalEvidence.Designer.cs
@@ -0,0 +1,1734 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722032612_AddLandMiscellaneousMasterFileIdToLMRentalEvidence")]
+    partial class AddLandMiscellaneousMasterFileIdToLMRentalEvidence
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMRentalEvidence_LandMiscellaneousMasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany("RentalEvidences")
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LandMiscellaneousMasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Navigation("RentalEvidences");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722032612_AddLandMiscellaneousMasterFileIdToLMRentalEvidence.cs b/Migrations/20250722032612_AddLandMiscellaneousMasterFileIdToLMRentalEvidence.cs
new file mode 100644
index 0000000..3767ed2
--- /dev/null
+++ b/Migrations/20250722032612_AddLandMiscellaneousMasterFileIdToLMRentalEvidence.cs
@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddLandMiscellaneousMasterFileIdToLMRentalEvidence : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "LandMiscellaneousMasterFileId",
+                table: "LMRentalEvidences",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LMRentalEvidence_LandMiscellaneousMasterFileId",
+                table: "LMRentalEvidences",
+                column: "LandMiscellaneousMasterFileId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_LMRentalEvidences_LandMiscellaneousMasterFiles_LandMiscella~",
+                table: "LMRentalEvidences",
+                column: "LandMiscellaneousMasterFileId",
+                principalTable: "LandMiscellaneousMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.SetNull);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_LMRentalEvidences_LandMiscellaneousMasterFiles_LandMiscella~",
+                table: "LMRentalEvidences");
+
+            migrationBuilder.DropIndex(
+                name: "IX_LMRentalEvidence_LandMiscellaneousMasterFileId",
+                table: "LMRentalEvidences");
+
+            migrationBuilder.DropColumn(
+                name: "LandMiscellaneousMasterFileId",
+                table: "LMRentalEvidences");
+        }
+    }
+}
diff --git a/Migrations/20250722064047_AddLandMiscellaneousMasterFileIdToLMTables.Designer.cs b/Migrations/20250722064047_AddLandMiscellaneousMasterFileIdToLMTables.Designer.cs
new file mode 100644
index 0000000..e5d2a65
--- /dev/null
+++ b/Migrations/20250722064047_AddLandMiscellaneousMasterFileIdToLMTables.Designer.cs
@@ -0,0 +1,1768 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722064047_AddLandMiscellaneousMasterFileIdToLMTables")]
+    partial class AddLandMiscellaneousMasterFileIdToLMTables
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMBuildingRates_LandMiscellaneousMasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMPastValuation_LandMiscellaneousMasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMRentalEvidence_LandMiscellaneousMasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMSalesEvidence_LandMiscellaneousMasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany()
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LandMiscellaneousMasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany()
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LandMiscellaneousMasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany()
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LandMiscellaneousMasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany()
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LandMiscellaneousMasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722064047_AddLandMiscellaneousMasterFileIdToLMTables.cs b/Migrations/20250722064047_AddLandMiscellaneousMasterFileIdToLMTables.cs
new file mode 100644
index 0000000..bcf1fea
--- /dev/null
+++ b/Migrations/20250722064047_AddLandMiscellaneousMasterFileIdToLMTables.cs
@@ -0,0 +1,111 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddLandMiscellaneousMasterFileIdToLMTables : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "LandMiscellaneousMasterFileId",
+                table: "LMSalesEvidences",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "LandMiscellaneousMasterFileId",
+                table: "LMPastValuations",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "LandMiscellaneousMasterFileId",
+                table: "LMBuildingRates",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LMSalesEvidence_LandMiscellaneousMasterFileId",
+                table: "LMSalesEvidences",
+                column: "LandMiscellaneousMasterFileId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LMPastValuation_LandMiscellaneousMasterFileId",
+                table: "LMPastValuations",
+                column: "LandMiscellaneousMasterFileId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LMBuildingRates_LandMiscellaneousMasterFileId",
+                table: "LMBuildingRates",
+                column: "LandMiscellaneousMasterFileId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_LMBuildingRates_LandMiscellaneousMasterFiles_LandMiscellane~",
+                table: "LMBuildingRates",
+                column: "LandMiscellaneousMasterFileId",
+                principalTable: "LandMiscellaneousMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.SetNull);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_LMPastValuations_LandMiscellaneousMasterFiles_LandMiscellan~",
+                table: "LMPastValuations",
+                column: "LandMiscellaneousMasterFileId",
+                principalTable: "LandMiscellaneousMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.SetNull);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_LMSalesEvidences_LandMiscellaneousMasterFiles_LandMiscellan~",
+                table: "LMSalesEvidences",
+                column: "LandMiscellaneousMasterFileId",
+                principalTable: "LandMiscellaneousMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.SetNull);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_LMBuildingRates_LandMiscellaneousMasterFiles_LandMiscellane~",
+                table: "LMBuildingRates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_LMPastValuations_LandMiscellaneousMasterFiles_LandMiscellan~",
+                table: "LMPastValuations");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_LMSalesEvidences_LandMiscellaneousMasterFiles_LandMiscellan~",
+                table: "LMSalesEvidences");
+
+            migrationBuilder.DropIndex(
+                name: "IX_LMSalesEvidence_LandMiscellaneousMasterFileId",
+                table: "LMSalesEvidences");
+
+            migrationBuilder.DropIndex(
+                name: "IX_LMPastValuation_LandMiscellaneousMasterFileId",
+                table: "LMPastValuations");
+
+            migrationBuilder.DropIndex(
+                name: "IX_LMBuildingRates_LandMiscellaneousMasterFileId",
+                table: "LMBuildingRates");
+
+            migrationBuilder.DropColumn(
+                name: "LandMiscellaneousMasterFileId",
+                table: "LMSalesEvidences");
+
+            migrationBuilder.DropColumn(
+                name: "LandMiscellaneousMasterFileId",
+                table: "LMPastValuations");
+
+            migrationBuilder.DropColumn(
+                name: "LandMiscellaneousMasterFileId",
+                table: "LMBuildingRates");
+        }
+    }
+}
diff --git a/Migrations/20250722140643_CreateLALotsTable.Designer.cs b/Migrations/20250722140643_CreateLALotsTable.Designer.cs
new file mode 100644
index 0000000..848e9c5
--- /dev/null
+++ b/Migrations/20250722140643_CreateLALotsTable.Designer.cs
@@ -0,0 +1,1995 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722140643_CreateLALotsTable")]
+    partial class CreateLALotsTable
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722140643_CreateLALotsTable.cs b/Migrations/20250722140643_CreateLALotsTable.cs
new file mode 100644
index 0000000..e7ef445
--- /dev/null
+++ b/Migrations/20250722140643_CreateLALotsTable.cs
@@ -0,0 +1,50 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class CreateLALotsTable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "LALots",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    MasterFileId = table.Column<int>(type: "integer", nullable: false),
+                    Coordinates = table.Column<string>(type: "text", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_LALots", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_LALots_LandAquisitionMasterFiles_MasterFileId",
+                        column: x => x.MasterFileId,
+                        principalTable: "LandAquisitionMasterFiles",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LALots_MasterFileId",
+                table: "LALots",
+                column: "MasterFileId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "LALots");
+        }
+    }
+}
diff --git a/Migrations/20250722142137_CreateLACoordinateTables.Designer.cs b/Migrations/20250722142137_CreateLACoordinateTables.Designer.cs
new file mode 100644
index 0000000..e18ce9a
--- /dev/null
+++ b/Migrations/20250722142137_CreateLACoordinateTables.Designer.cs
@@ -0,0 +1,2151 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722142137_CreateLACoordinateTables")]
+    partial class CreateLACoordinateTables
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722142137_CreateLACoordinateTables.cs b/Migrations/20250722142137_CreateLACoordinateTables.cs
new file mode 100644
index 0000000..459f64e
--- /dev/null
+++ b/Migrations/20250722142137_CreateLACoordinateTables.cs
@@ -0,0 +1,140 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class CreateLACoordinateTables : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "BuildingRatesLACoordinates",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ReportId = table.Column<int>(type: "integer", nullable: false),
+                    Coordinates = table.Column<string>(type: "text", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_BuildingRatesLACoordinates", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_BuildingRatesLACoordinates_Reports_ReportId",
+                        column: x => x.ReportId,
+                        principalTable: "Reports",
+                        principalColumn: "ReportId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "PastValuationsLACoordinates",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ReportId = table.Column<int>(type: "integer", nullable: false),
+                    Coordinates = table.Column<string>(type: "text", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_PastValuationsLACoordinates", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_PastValuationsLACoordinates_Reports_ReportId",
+                        column: x => x.ReportId,
+                        principalTable: "Reports",
+                        principalColumn: "ReportId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "RentalEvidenceLACoordinates",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ReportId = table.Column<int>(type: "integer", nullable: false),
+                    Coordinates = table.Column<string>(type: "text", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_RentalEvidenceLACoordinates", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_RentalEvidenceLACoordinates_Reports_ReportId",
+                        column: x => x.ReportId,
+                        principalTable: "Reports",
+                        principalColumn: "ReportId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "SalesEvidenceLACoordinates",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ReportId = table.Column<int>(type: "integer", nullable: false),
+                    Coordinates = table.Column<string>(type: "text", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_SalesEvidenceLACoordinates", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_SalesEvidenceLACoordinates_Reports_ReportId",
+                        column: x => x.ReportId,
+                        principalTable: "Reports",
+                        principalColumn: "ReportId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_BuildingRatesLACoordinates_ReportId",
+                table: "BuildingRatesLACoordinates",
+                column: "ReportId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PastValuationsLACoordinates_ReportId",
+                table: "PastValuationsLACoordinates",
+                column: "ReportId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RentalEvidenceLACoordinates_ReportId",
+                table: "RentalEvidenceLACoordinates",
+                column: "ReportId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SalesEvidenceLACoordinates_ReportId",
+                table: "SalesEvidenceLACoordinates",
+                column: "ReportId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "BuildingRatesLACoordinates");
+
+            migrationBuilder.DropTable(
+                name: "PastValuationsLACoordinates");
+
+            migrationBuilder.DropTable(
+                name: "RentalEvidenceLACoordinates");
+
+            migrationBuilder.DropTable(
+                name: "SalesEvidenceLACoordinates");
+        }
+    }
+}
diff --git a/Migrations/20250722163129_UpdateCoordinateTablesForeignKeys.Designer.cs b/Migrations/20250722163129_UpdateCoordinateTablesForeignKeys.Designer.cs
new file mode 100644
index 0000000..3f7b14c
--- /dev/null
+++ b/Migrations/20250722163129_UpdateCoordinateTablesForeignKeys.Designer.cs
@@ -0,0 +1,2151 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722163129_UpdateCoordinateTablesForeignKeys")]
+    partial class UpdateCoordinateTablesForeignKeys
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BuildingRateId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingRateId");
+
+                    b.ToTable("BuildingRatesLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("PastValuationId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PastValuationId");
+
+                    b.ToTable("PastValuationsLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RentalEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RentalEvidenceId");
+
+                    b.ToTable("RentalEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("SalesEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SalesEvidenceId");
+
+                    b.ToTable("SalesEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.BuildingRatesLA", "BuildingRate")
+                        .WithMany()
+                        .HasForeignKey("BuildingRateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BuildingRate");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.PastValuationsLA", "PastValuation")
+                        .WithMany()
+                        .HasForeignKey("PastValuationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PastValuation");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RentalEvidenceLA", "RentalEvidence")
+                        .WithMany()
+                        .HasForeignKey("RentalEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RentalEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.SalesEvidenceLA", "SalesEvidence")
+                        .WithMany()
+                        .HasForeignKey("SalesEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SalesEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722163129_UpdateCoordinateTablesForeignKeys.cs b/Migrations/20250722163129_UpdateCoordinateTablesForeignKeys.cs
new file mode 100644
index 0000000..1b52057
--- /dev/null
+++ b/Migrations/20250722163129_UpdateCoordinateTablesForeignKeys.cs
@@ -0,0 +1,194 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class UpdateCoordinateTablesForeignKeys : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_BuildingRatesLACoordinates_Reports_ReportId",
+                table: "BuildingRatesLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PastValuationsLACoordinates_Reports_ReportId",
+                table: "PastValuationsLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_Reports_ReportId",
+                table: "RentalEvidenceLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_Reports_ReportId",
+                table: "SalesEvidenceLACoordinates");
+
+            migrationBuilder.RenameColumn(
+                name: "ReportId",
+                table: "SalesEvidenceLACoordinates",
+                newName: "SalesEvidenceId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_SalesEvidenceLACoordinates_ReportId",
+                table: "SalesEvidenceLACoordinates",
+                newName: "IX_SalesEvidenceLACoordinates_SalesEvidenceId");
+
+            migrationBuilder.RenameColumn(
+                name: "ReportId",
+                table: "RentalEvidenceLACoordinates",
+                newName: "RentalEvidenceId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_RentalEvidenceLACoordinates_ReportId",
+                table: "RentalEvidenceLACoordinates",
+                newName: "IX_RentalEvidenceLACoordinates_RentalEvidenceId");
+
+            migrationBuilder.RenameColumn(
+                name: "ReportId",
+                table: "PastValuationsLACoordinates",
+                newName: "PastValuationId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_PastValuationsLACoordinates_ReportId",
+                table: "PastValuationsLACoordinates",
+                newName: "IX_PastValuationsLACoordinates_PastValuationId");
+
+            migrationBuilder.RenameColumn(
+                name: "ReportId",
+                table: "BuildingRatesLACoordinates",
+                newName: "BuildingRateId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_BuildingRatesLACoordinates_ReportId",
+                table: "BuildingRatesLACoordinates",
+                newName: "IX_BuildingRatesLACoordinates_BuildingRateId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_BuildingRatesLACoordinates_BuildingRatesLA_BuildingRateId",
+                table: "BuildingRatesLACoordinates",
+                column: "BuildingRateId",
+                principalTable: "BuildingRatesLA",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PastValuationsLACoordinates_PastValuationsLA_PastValuationId",
+                table: "PastValuationsLACoordinates",
+                column: "PastValuationId",
+                principalTable: "PastValuationsLA",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_RentalEvidencesLA_RentalEvidenc~",
+                table: "RentalEvidenceLACoordinates",
+                column: "RentalEvidenceId",
+                principalTable: "RentalEvidencesLA",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_SalesEvidencesLA_SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates",
+                column: "SalesEvidenceId",
+                principalTable: "SalesEvidencesLA",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_BuildingRatesLACoordinates_BuildingRatesLA_BuildingRateId",
+                table: "BuildingRatesLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PastValuationsLACoordinates_PastValuationsLA_PastValuationId",
+                table: "PastValuationsLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_RentalEvidencesLA_RentalEvidenc~",
+                table: "RentalEvidenceLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_SalesEvidencesLA_SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates");
+
+            migrationBuilder.RenameColumn(
+                name: "SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates",
+                newName: "ReportId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_SalesEvidenceLACoordinates_SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates",
+                newName: "IX_SalesEvidenceLACoordinates_ReportId");
+
+            migrationBuilder.RenameColumn(
+                name: "RentalEvidenceId",
+                table: "RentalEvidenceLACoordinates",
+                newName: "ReportId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_RentalEvidenceLACoordinates_RentalEvidenceId",
+                table: "RentalEvidenceLACoordinates",
+                newName: "IX_RentalEvidenceLACoordinates_ReportId");
+
+            migrationBuilder.RenameColumn(
+                name: "PastValuationId",
+                table: "PastValuationsLACoordinates",
+                newName: "ReportId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_PastValuationsLACoordinates_PastValuationId",
+                table: "PastValuationsLACoordinates",
+                newName: "IX_PastValuationsLACoordinates_ReportId");
+
+            migrationBuilder.RenameColumn(
+                name: "BuildingRateId",
+                table: "BuildingRatesLACoordinates",
+                newName: "ReportId");
+
+            migrationBuilder.RenameIndex(
+                name: "IX_BuildingRatesLACoordinates_BuildingRateId",
+                table: "BuildingRatesLACoordinates",
+                newName: "IX_BuildingRatesLACoordinates_ReportId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_BuildingRatesLACoordinates_Reports_ReportId",
+                table: "BuildingRatesLACoordinates",
+                column: "ReportId",
+                principalTable: "Reports",
+                principalColumn: "ReportId",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PastValuationsLACoordinates_Reports_ReportId",
+                table: "PastValuationsLACoordinates",
+                column: "ReportId",
+                principalTable: "Reports",
+                principalColumn: "ReportId",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_Reports_ReportId",
+                table: "RentalEvidenceLACoordinates",
+                column: "ReportId",
+                principalTable: "Reports",
+                principalColumn: "ReportId",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_Reports_ReportId",
+                table: "SalesEvidenceLACoordinates",
+                column: "ReportId",
+                principalTable: "Reports",
+                principalColumn: "ReportId",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
diff --git a/Migrations/20250722164706_UpdatePastValuationsLAMasterFileIdToIntWithConversion.Designer.cs b/Migrations/20250722164706_UpdatePastValuationsLAMasterFileIdToIntWithConversion.Designer.cs
new file mode 100644
index 0000000..dd1fd11
--- /dev/null
+++ b/Migrations/20250722164706_UpdatePastValuationsLAMasterFileIdToIntWithConversion.Designer.cs
@@ -0,0 +1,2160 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722164706_UpdatePastValuationsLAMasterFileIdToIntWithConversion")]
+    partial class UpdatePastValuationsLAMasterFileIdToIntWithConversion
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BuildingRateId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingRateId");
+
+                    b.ToTable("BuildingRatesLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("PastValuationId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PastValuationId");
+
+                    b.ToTable("PastValuationsLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RentalEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RentalEvidenceId");
+
+                    b.ToTable("RentalEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("SalesEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SalesEvidenceId");
+
+                    b.ToTable("SalesEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.BuildingRatesLA", "BuildingRate")
+                        .WithMany()
+                        .HasForeignKey("BuildingRateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BuildingRate");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.PastValuationsLA", "PastValuation")
+                        .WithMany()
+                        .HasForeignKey("PastValuationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PastValuation");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RentalEvidenceLA", "RentalEvidence")
+                        .WithMany()
+                        .HasForeignKey("RentalEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RentalEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.SalesEvidenceLA", "SalesEvidence")
+                        .WithMany()
+                        .HasForeignKey("SalesEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SalesEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722164706_UpdatePastValuationsLAMasterFileIdToIntWithConversion.cs b/Migrations/20250722164706_UpdatePastValuationsLAMasterFileIdToIntWithConversion.cs
new file mode 100644
index 0000000..2bc754f
--- /dev/null
+++ b/Migrations/20250722164706_UpdatePastValuationsLAMasterFileIdToIntWithConversion.cs
@@ -0,0 +1,94 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class UpdatePastValuationsLAMasterFileIdToIntWithConversion : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Step 1: Add a temporary integer column
+            migrationBuilder.AddColumn<int>(
+                name: "MasterFileId_temp",
+                table: "PastValuationsLA",
+                type: "integer",
+                nullable: true);
+
+            // Step 2: Update the temporary column with converted values
+            // Only convert values that are valid integers, set others to NULL
+            migrationBuilder.Sql(@"
+                UPDATE ""PastValuationsLA"" 
+                SET ""MasterFileId_temp"" = CASE 
+                    WHEN ""MasterFileId"" ~ '^[0-9]+$' THEN ""MasterFileId""::integer 
+                    ELSE NULL 
+                END;");
+
+            // Step 3: Drop the old text column
+            migrationBuilder.DropColumn(
+                name: "MasterFileId",
+                table: "PastValuationsLA");
+
+            // Step 4: Rename the temporary column to the original name
+            migrationBuilder.RenameColumn(
+                name: "MasterFileId_temp",
+                table: "PastValuationsLA",
+                newName: "MasterFileId");
+
+            // Step 5: Make the column NOT NULL (set default value for any remaining nulls)
+            migrationBuilder.Sql(@"
+                UPDATE ""PastValuationsLA"" 
+                SET ""MasterFileId"" = 1 
+                WHERE ""MasterFileId"" IS NULL;");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "MasterFileId",
+                table: "PastValuationsLA",
+                type: "integer",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            // Step 6: Create index for foreign key
+            migrationBuilder.CreateIndex(
+                name: "IX_PastValuationsLA_MasterFileId",
+                table: "PastValuationsLA",
+                column: "MasterFileId");
+
+            // Step 7: Add foreign key constraint
+            migrationBuilder.AddForeignKey(
+                name: "FK_PastValuationsLA_LandAquisitionMasterFiles_MasterFileId",
+                table: "PastValuationsLA",
+                column: "MasterFileId",
+                principalTable: "LandAquisitionMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            // Drop foreign key constraint
+            migrationBuilder.DropForeignKey(
+                name: "FK_PastValuationsLA_LandAquisitionMasterFiles_MasterFileId",
+                table: "PastValuationsLA");
+
+            // Drop index
+            migrationBuilder.DropIndex(
+                name: "IX_PastValuationsLA_MasterFileId",
+                table: "PastValuationsLA");
+
+            // Convert back to string
+            migrationBuilder.AlterColumn<string>(
+                name: "MasterFileId",
+                table: "PastValuationsLA",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer");
+        }
+    }
+}
diff --git a/Migrations/20250722165759_ConvertBuildingRatesLAMasterFileIdToInt.Designer.cs b/Migrations/20250722165759_ConvertBuildingRatesLAMasterFileIdToInt.Designer.cs
new file mode 100644
index 0000000..e1781f1
--- /dev/null
+++ b/Migrations/20250722165759_ConvertBuildingRatesLAMasterFileIdToInt.Designer.cs
@@ -0,0 +1,2169 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722165759_ConvertBuildingRatesLAMasterFileIdToInt")]
+    partial class ConvertBuildingRatesLAMasterFileIdToInt
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BuildingRateId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingRateId");
+
+                    b.ToTable("BuildingRatesLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("PastValuationId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PastValuationId");
+
+                    b.ToTable("PastValuationsLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RentalEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RentalEvidenceId");
+
+                    b.ToTable("RentalEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("SalesEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SalesEvidenceId");
+
+                    b.ToTable("SalesEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.BuildingRatesLA", "BuildingRate")
+                        .WithMany()
+                        .HasForeignKey("BuildingRateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BuildingRate");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.PastValuationsLA", "PastValuation")
+                        .WithMany()
+                        .HasForeignKey("PastValuationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PastValuation");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RentalEvidenceLA", "RentalEvidence")
+                        .WithMany()
+                        .HasForeignKey("RentalEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RentalEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.SalesEvidenceLA", "SalesEvidence")
+                        .WithMany()
+                        .HasForeignKey("SalesEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SalesEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722165759_ConvertBuildingRatesLAMasterFileIdToInt.cs b/Migrations/20250722165759_ConvertBuildingRatesLAMasterFileIdToInt.cs
new file mode 100644
index 0000000..9912d2d
--- /dev/null
+++ b/Migrations/20250722165759_ConvertBuildingRatesLAMasterFileIdToInt.cs
@@ -0,0 +1,114 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class ConvertBuildingRatesLAMasterFileIdToInt : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Step 1: Add a temporary column for the integer values
+            migrationBuilder.AddColumn<int>(
+                name: "MasterFileId_Temp",
+                table: "BuildingRatesLA",
+                type: "integer",
+                nullable: true);
+
+            // Step 2: Convert existing string data to integers with validation
+            migrationBuilder.Sql(@"
+                UPDATE ""BuildingRatesLA""
+                SET ""MasterFileId_Temp"" = CASE 
+                    WHEN ""MasterFileId"" ~ '^[0-9]+$' AND ""MasterFileId"" != '' THEN 
+                        CAST(""MasterFileId"" AS integer)
+                    ELSE 
+                        1  -- Default to 1 if invalid or empty
+                END;
+            ");
+
+            // Step 3: Drop the old string column
+            migrationBuilder.DropColumn(
+                name: "MasterFileId",
+                table: "BuildingRatesLA");
+
+            // Step 4: Rename the temporary column to the original name
+            migrationBuilder.RenameColumn(
+                name: "MasterFileId_Temp",
+                table: "BuildingRatesLA",
+                newName: "MasterFileId");
+
+            // Step 5: Make the column non-nullable
+            migrationBuilder.AlterColumn<int>(
+                name: "MasterFileId",
+                table: "BuildingRatesLA",
+                type: "integer",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            // Step 6: Create index and foreign key
+            migrationBuilder.CreateIndex(
+                name: "IX_BuildingRatesLA_MasterFileId",
+                table: "BuildingRatesLA",
+                column: "MasterFileId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_BuildingRatesLA_LandAquisitionMasterFiles_MasterFileId",
+                table: "BuildingRatesLA",
+                column: "MasterFileId",
+                principalTable: "LandAquisitionMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            // Step 1: Drop foreign key and index
+            migrationBuilder.DropForeignKey(
+                name: "FK_BuildingRatesLA_LandAquisitionMasterFiles_MasterFileId",
+                table: "BuildingRatesLA");
+
+            migrationBuilder.DropIndex(
+                name: "IX_BuildingRatesLA_MasterFileId",
+                table: "BuildingRatesLA");
+
+            // Step 2: Add temporary string column
+            migrationBuilder.AddColumn<string>(
+                name: "MasterFileId_Temp",
+                table: "BuildingRatesLA",
+                type: "text",
+                nullable: true);
+
+            // Step 3: Convert integer values back to strings
+            migrationBuilder.Sql(@"
+                UPDATE ""BuildingRatesLA""
+                SET ""MasterFileId_Temp"" = CAST(""MasterFileId"" AS text);
+            ");
+
+            // Step 4: Drop the integer column
+            migrationBuilder.DropColumn(
+                name: "MasterFileId",
+                table: "BuildingRatesLA");
+
+            // Step 5: Rename temporary column back
+            migrationBuilder.RenameColumn(
+                name: "MasterFileId_Temp",
+                table: "BuildingRatesLA",
+                newName: "MasterFileId");
+
+            // Step 6: Make column non-nullable string
+            migrationBuilder.AlterColumn<string>(
+                name: "MasterFileId",
+                table: "BuildingRatesLA",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text",
+                oldNullable: true);
+        }
+    }
+}
diff --git a/Migrations/20250722170349_ConvertRentalEvidenceLAMasterFileIdToInt.cs b/Migrations/20250722170349_ConvertRentalEvidenceLAMasterFileIdToInt.cs
new file mode 100644
index 0000000..ac93a08
--- /dev/null
+++ b/Migrations/20250722170349_ConvertRentalEvidenceLAMasterFileIdToInt.cs
@@ -0,0 +1,114 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class ConvertRentalEvidenceLAMasterFileIdToInt : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Step 1: Add a temporary column for the integer values
+            migrationBuilder.AddColumn<int>(
+                name: "MasterFileId_Temp",
+                table: "RentalEvidencesLA",
+                type: "integer",
+                nullable: true);
+
+            // Step 2: Convert existing string data to integers with validation
+            migrationBuilder.Sql(@"
+                UPDATE ""RentalEvidencesLA""
+                SET ""MasterFileId_Temp"" = CASE 
+                    WHEN ""MasterFileId"" ~ '^[0-9]+$' AND ""MasterFileId"" != '' THEN 
+                        CAST(""MasterFileId"" AS integer)
+                    ELSE 
+                        1  -- Default to 1 if invalid or empty
+                END;
+            ");
+
+            // Step 3: Drop the old string column
+            migrationBuilder.DropColumn(
+                name: "MasterFileId",
+                table: "RentalEvidencesLA");
+
+            // Step 4: Rename the temporary column to the original name
+            migrationBuilder.RenameColumn(
+                name: "MasterFileId_Temp",
+                table: "RentalEvidencesLA",
+                newName: "MasterFileId");
+
+            // Step 5: Make the column non-nullable
+            migrationBuilder.AlterColumn<int>(
+                name: "MasterFileId",
+                table: "RentalEvidencesLA",
+                type: "integer",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            // Step 6: Create index and foreign key
+            migrationBuilder.CreateIndex(
+                name: "IX_RentalEvidencesLA_MasterFileId",
+                table: "RentalEvidencesLA",
+                column: "MasterFileId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RentalEvidencesLA_LandAquisitionMasterFiles_MasterFileId",
+                table: "RentalEvidencesLA",
+                column: "MasterFileId",
+                principalTable: "LandAquisitionMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            // Step 1: Drop foreign key and index
+            migrationBuilder.DropForeignKey(
+                name: "FK_RentalEvidencesLA_LandAquisitionMasterFiles_MasterFileId",
+                table: "RentalEvidencesLA");
+
+            migrationBuilder.DropIndex(
+                name: "IX_RentalEvidencesLA_MasterFileId",
+                table: "RentalEvidencesLA");
+
+            // Step 2: Add temporary string column
+            migrationBuilder.AddColumn<string>(
+                name: "MasterFileId_Temp",
+                table: "RentalEvidencesLA",
+                type: "text",
+                nullable: true);
+
+            // Step 3: Convert integer values back to strings
+            migrationBuilder.Sql(@"
+                UPDATE ""RentalEvidencesLA""
+                SET ""MasterFileId_Temp"" = CAST(""MasterFileId"" AS text);
+            ");
+
+            // Step 4: Drop the integer column
+            migrationBuilder.DropColumn(
+                name: "MasterFileId",
+                table: "RentalEvidencesLA");
+
+            // Step 5: Rename temporary column back
+            migrationBuilder.RenameColumn(
+                name: "MasterFileId_Temp",
+                table: "RentalEvidencesLA",
+                newName: "MasterFileId");
+
+            // Step 6: Make column non-nullable string
+            migrationBuilder.AlterColumn<string>(
+                name: "MasterFileId",
+                table: "RentalEvidencesLA",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text",
+                oldNullable: true);
+        }
+    }
+}
diff --git a/Migrations/20250722172342_ConvertSalesEvidenceLAMasterFileIdToInt.Designer.cs b/Migrations/20250722172342_ConvertSalesEvidenceLAMasterFileIdToInt.Designer.cs
new file mode 100644
index 0000000..ba72b36
--- /dev/null
+++ b/Migrations/20250722172342_ConvertSalesEvidenceLAMasterFileIdToInt.Designer.cs
@@ -0,0 +1,2187 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722172342_ConvertSalesEvidenceLAMasterFileIdToInt")]
+    partial class ConvertSalesEvidenceLAMasterFileIdToInt
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BuildingRateId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingRateId");
+
+                    b.ToTable("BuildingRatesLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("PastValuationId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PastValuationId");
+
+                    b.ToTable("PastValuationsLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("RentalEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RentalEvidenceId");
+
+                    b.ToTable("RentalEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("SalesEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SalesEvidenceId");
+
+                    b.ToTable("SalesEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.BuildingRatesLA", "BuildingRate")
+                        .WithMany()
+                        .HasForeignKey("BuildingRateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BuildingRate");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.PastValuationsLA", "PastValuation")
+                        .WithMany()
+                        .HasForeignKey("PastValuationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PastValuation");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RentalEvidenceLA", "RentalEvidence")
+                        .WithMany()
+                        .HasForeignKey("RentalEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RentalEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.SalesEvidenceLA", "SalesEvidence")
+                        .WithMany()
+                        .HasForeignKey("SalesEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("SalesEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722172342_ConvertSalesEvidenceLAMasterFileIdToInt.cs b/Migrations/20250722172342_ConvertSalesEvidenceLAMasterFileIdToInt.cs
new file mode 100644
index 0000000..cadee34
--- /dev/null
+++ b/Migrations/20250722172342_ConvertSalesEvidenceLAMasterFileIdToInt.cs
@@ -0,0 +1,119 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class ConvertSalesEvidenceLAMasterFileIdToInt : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Step 1: Add temporary column for integer MasterFileId
+            migrationBuilder.AddColumn<int>(
+                name: "MasterFileId_temp",
+                table: "SalesEvidencesLA",
+                type: "integer",
+                nullable: true);
+
+            // Step 2: Update temp column with converted values - only for numeric strings
+            migrationBuilder.Sql(@"
+                UPDATE ""SalesEvidencesLA""
+                SET ""MasterFileId_temp"" = CAST(""MasterFileId"" AS INTEGER)
+                WHERE ""MasterFileId"" ~ '^[0-9]+$'
+                AND EXISTS (
+                    SELECT 1 FROM ""LandAquisitionMasterFiles"" 
+                    WHERE ""Id"" = CAST(""SalesEvidencesLA"".""MasterFileId"" AS INTEGER)
+                );
+            ");
+
+            // Step 3: Delete records with invalid MasterFileId references
+            migrationBuilder.Sql(@"
+                DELETE FROM ""SalesEvidencesLA""
+                WHERE ""MasterFileId_temp"" IS NULL;
+            ");
+
+            // Step 4: Drop the old column
+            migrationBuilder.DropColumn(
+                name: "MasterFileId",
+                table: "SalesEvidencesLA");
+
+            // Step 5: Rename temp column
+            migrationBuilder.RenameColumn(
+                name: "MasterFileId_temp",
+                table: "SalesEvidencesLA",
+                newName: "MasterFileId");
+
+            // Step 6: Make the column non-nullable
+            migrationBuilder.AlterColumn<int>(
+                name: "MasterFileId",
+                table: "SalesEvidencesLA",
+                type: "integer",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            // Step 7: Create index and foreign key
+            migrationBuilder.CreateIndex(
+                name: "IX_SalesEvidencesLA_MasterFileId",
+                table: "SalesEvidencesLA",
+                column: "MasterFileId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SalesEvidencesLA_LandAquisitionMasterFiles_MasterFileId",
+                table: "SalesEvidencesLA",
+                column: "MasterFileId",
+                principalTable: "LandAquisitionMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_SalesEvidencesLA_LandAquisitionMasterFiles_MasterFileId",
+                table: "SalesEvidencesLA");
+
+            migrationBuilder.DropIndex(
+                name: "IX_SalesEvidencesLA_MasterFileId",
+                table: "SalesEvidencesLA");
+
+            // Add temporary string column
+            migrationBuilder.AddColumn<string>(
+                name: "MasterFileId_temp",
+                table: "SalesEvidencesLA",
+                type: "text",
+                nullable: true);
+
+            // Convert integer values back to string
+            migrationBuilder.Sql(@"
+                UPDATE ""SalesEvidencesLA""
+                SET ""MasterFileId_temp"" = CAST(""MasterFileId"" AS TEXT);
+            ");
+
+            // Drop the integer column
+            migrationBuilder.DropColumn(
+                name: "MasterFileId",
+                table: "SalesEvidencesLA");
+
+            // Rename temp column back
+            migrationBuilder.RenameColumn(
+                name: "MasterFileId_temp",
+                table: "SalesEvidencesLA",
+                newName: "MasterFileId");
+
+            // Make the column non-nullable
+            migrationBuilder.AlterColumn<string>(
+                name: "MasterFileId",
+                table: "SalesEvidencesLA",
+                type: "text",
+                nullable: false,
+                oldClrType: typeof(string),
+                oldType: "text",
+                oldNullable: true);
+        }
+    }
+}
diff --git a/Migrations/20250722200849_AddMasterfileIdToCoordinates.Designer.cs b/Migrations/20250722200849_AddMasterfileIdToCoordinates.Designer.cs
new file mode 100644
index 0000000..6cfa6e6
--- /dev/null
+++ b/Migrations/20250722200849_AddMasterfileIdToCoordinates.Designer.cs
@@ -0,0 +1,2239 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250722200849_AddMasterfileIdToCoordinates")]
+    partial class AddMasterfileIdToCoordinates
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BuildingRateId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingRateId");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.ToTable("BuildingRatesLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("PastValuationId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("PastValuationId");
+
+                    b.ToTable("PastValuationsLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RentalEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("RentalEvidenceId");
+
+                    b.ToTable("RentalEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("SalesEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("SalesEvidenceId");
+
+                    b.ToTable("SalesEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.BuildingRatesLA", "BuildingRate")
+                        .WithMany()
+                        .HasForeignKey("BuildingRateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BuildingRate");
+
+                    b.Navigation("Masterfile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.PastValuationsLA", "PastValuation")
+                        .WithMany()
+                        .HasForeignKey("PastValuationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("PastValuation");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.RentalEvidenceLA", "RentalEvidence")
+                        .WithMany()
+                        .HasForeignKey("RentalEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("RentalEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.SalesEvidenceLA", "SalesEvidence")
+                        .WithMany()
+                        .HasForeignKey("SalesEvidenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("SalesEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250722200849_AddMasterfileIdToCoordinates.cs b/Migrations/20250722200849_AddMasterfileIdToCoordinates.cs
new file mode 100644
index 0000000..d2c4ffb
--- /dev/null
+++ b/Migrations/20250722200849_AddMasterfileIdToCoordinates.cs
@@ -0,0 +1,146 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddMasterfileIdToCoordinates : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "MasterfileId",
+                table: "SalesEvidenceLACoordinates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MasterfileId",
+                table: "RentalEvidenceLACoordinates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MasterfileId",
+                table: "PastValuationsLACoordinates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "MasterfileId",
+                table: "BuildingRatesLACoordinates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_SalesEvidenceLACoordinates_MasterfileId",
+                table: "SalesEvidenceLACoordinates",
+                column: "MasterfileId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_RentalEvidenceLACoordinates_MasterfileId",
+                table: "RentalEvidenceLACoordinates",
+                column: "MasterfileId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_PastValuationsLACoordinates_MasterfileId",
+                table: "PastValuationsLACoordinates",
+                column: "MasterfileId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_BuildingRatesLACoordinates_MasterfileId",
+                table: "BuildingRatesLACoordinates",
+                column: "MasterfileId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_BuildingRatesLACoordinates_LandAquisitionMasterFiles_Master~",
+                table: "BuildingRatesLACoordinates",
+                column: "MasterfileId",
+                principalTable: "LandAquisitionMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PastValuationsLACoordinates_LandAquisitionMasterFiles_Maste~",
+                table: "PastValuationsLACoordinates",
+                column: "MasterfileId",
+                principalTable: "LandAquisitionMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_LandAquisitionMasterFiles_Maste~",
+                table: "RentalEvidenceLACoordinates",
+                column: "MasterfileId",
+                principalTable: "LandAquisitionMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_LandAquisitionMasterFiles_Master~",
+                table: "SalesEvidenceLACoordinates",
+                column: "MasterfileId",
+                principalTable: "LandAquisitionMasterFiles",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_BuildingRatesLACoordinates_LandAquisitionMasterFiles_Master~",
+                table: "BuildingRatesLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PastValuationsLACoordinates_LandAquisitionMasterFiles_Maste~",
+                table: "PastValuationsLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_LandAquisitionMasterFiles_Maste~",
+                table: "RentalEvidenceLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_LandAquisitionMasterFiles_Master~",
+                table: "SalesEvidenceLACoordinates");
+
+            migrationBuilder.DropIndex(
+                name: "IX_SalesEvidenceLACoordinates_MasterfileId",
+                table: "SalesEvidenceLACoordinates");
+
+            migrationBuilder.DropIndex(
+                name: "IX_RentalEvidenceLACoordinates_MasterfileId",
+                table: "RentalEvidenceLACoordinates");
+
+            migrationBuilder.DropIndex(
+                name: "IX_PastValuationsLACoordinates_MasterfileId",
+                table: "PastValuationsLACoordinates");
+
+            migrationBuilder.DropIndex(
+                name: "IX_BuildingRatesLACoordinates_MasterfileId",
+                table: "BuildingRatesLACoordinates");
+
+            migrationBuilder.DropColumn(
+                name: "MasterfileId",
+                table: "SalesEvidenceLACoordinates");
+
+            migrationBuilder.DropColumn(
+                name: "MasterfileId",
+                table: "RentalEvidenceLACoordinates");
+
+            migrationBuilder.DropColumn(
+                name: "MasterfileId",
+                table: "PastValuationsLACoordinates");
+
+            migrationBuilder.DropColumn(
+                name: "MasterfileId",
+                table: "BuildingRatesLACoordinates");
+        }
+    }
+}
diff --git a/Migrations/20250723061305_MakeEvidenceIdNullableInCoordinates.Designer.cs b/Migrations/20250723061305_MakeEvidenceIdNullableInCoordinates.Designer.cs
new file mode 100644
index 0000000..aff8510
--- /dev/null
+++ b/Migrations/20250723061305_MakeEvidenceIdNullableInCoordinates.Designer.cs
@@ -0,0 +1,2231 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using ValuationBackend.Data;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20250723061305_MakeEvidenceIdNullableInCoordinates")]
+    partial class MakeEvidenceIdNullableInCoordinates
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "9.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
+            modelBuilder.Entity("LandAquisitionMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFilesRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandAquisitionMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Description")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsRatingCard")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("RdSt")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<int>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Ward")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestId");
+
+                    b.ToTable("Assets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<decimal>("Area")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<string>("LandType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("AssetDivisions");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetNumberChange", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime?>("ChangedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateOfChange")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("FieldSize")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("FieldType")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OldAssetNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Reason")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AssetNumberChanges");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorAreaSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("YearOfConstruction")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("BuildingRatesLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("BuildingRateId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingRateId");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.ToTable("BuildingRatesLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessCategory")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AccessCategoryDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiredExtent")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquiringOfficerSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AcquisitionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AtPlanNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryBottom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryEast")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryNorth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundarySouth")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BoundaryWest")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChiefValuerRepresentativeSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfSection3BA")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DatePrepared")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DepthOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Frontage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("GramasewakaSignature")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandUseType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("LevelWithAccess")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheLand")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameOfTheVillage")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionsInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlantationDetails")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadLotNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PpCadNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("ConditionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Access")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Floor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Plantations")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertySubCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PropertyType")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RoadName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SelectWalls")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Terms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TsBop")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WardNumber")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("DomesticRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ImageData", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ImageBase64")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ImageData");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AgeYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToilet")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BathroomToiletDoorsFittings")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingClass")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingConditions")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BuildingName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Ceiling")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Condition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Conveniences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Design")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DetailOfBuilding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Door")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExpectedLifePeriodYears")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FoundationStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HandRail")
+                        .HasColumnType("text");
+
+                    b.Property<int>("InspectionReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NatureOfConstruction")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NoOfFloorsAboveGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsAboveGround");
+
+                    b.Property<string>("NoOfFloorsBelowGround")
+                        .HasColumnType("text")
+                        .HasColumnName("NoOfFloorsBelowGround");
+
+                    b.Property<string>("OtherDoors")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PantryCupboard")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParkingSpace")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofFrame")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoofMaterial")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Services")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Structure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallFinisher")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WallStructure")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Window")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WindowProtection")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InspectionReportId");
+
+                    b.ToTable("InspectionBuildings");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Property<int>("InspectionReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("InspectionReportId"));
+
+                    b.Property<string>("DetailsOfAssestsInventoryItems")
+                        .HasColumnType("text")
+                        .HasColumnName("DetailsOfAssestsInventoryItems");
+
+                    b.Property<string>("DetailsOfBusiness")
+                        .HasColumnType("text");
+
+                    b.Property<string>("District")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DsDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("InspectionDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MasterFileId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherConstructionDetails")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OtherInformation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remark")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("InspectionReportId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("InspectionReports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConstructedBy")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Cost")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorArea")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("YearOfConstruction")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMBuildingRates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNo_GnDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMPastValuations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePer")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMRentalEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("LMSalesEvidences");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LandMiscellaneousMasterFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Lots")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("MasterFileNo")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PlanNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestingAuthorityReferenceNo")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LandMiscellaneousMasterFiles");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.MasterDataItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Category")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MasterDataItems");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DateOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FileNoGNDivision")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanOfParticulars")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PurposeOfValuation")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("PastValuationsLA");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("PastValuationId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("PastValuationId");
+
+                    b.ToTable("PastValuationsLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PropertyCategories");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RatingRequest", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequestType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RatingRequests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("NewNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("ObsoleteNo")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("StreetName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("Reconciliations");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssessmentNo")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRateSQFT")
+                        .HasColumnType("text");
+
+                    b.Property<string>("HeadOfTerms")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RatePerSqft")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("RentalEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("RentalEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("RentalEvidenceId");
+
+                    b.ToTable("RentalEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Report", b =>
+                {
+                    b.Property<int>("ReportId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("ReportId"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("ReportId");
+
+                    b.ToTable("Reports");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("RatingReferenceNo")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("RequestTypeId")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Status")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("YearOfRevision")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RequestTypeId");
+
+                    b.ToTable("Requests");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RequestType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RequestTypes");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssetNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Consideration")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("DeedAttestedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeedNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionOfProperty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Extent")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FloorRate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LandRegistryReferences")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLatitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LocationLongitude")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LotNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("MasterFileRefNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("NotaryName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Occupier")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Owner")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PlanNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RateType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Remarks")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ReportId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Road")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Situation")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Vendor")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Village")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.HasIndex("ReportId");
+
+                    b.ToTable("SalesEvidencesLA", (string)null);
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SalesEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("SalesEvidenceId");
+
+                    b.ToTable("SalesEvidenceLACoordinates");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.User", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AssignedDivision")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpEmail")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmpName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("PasswordHash")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<byte[]>("PasswordSalt")
+                        .IsRequired()
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Position")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<byte[]>("ProfilePicture")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("AssignedDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("IsCompleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<int?>("LandAcquisitionId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("LandMiscellaneousId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ReferenceNumber")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("RequestId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("TaskType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("UserId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkItemDescription")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserTasks");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccessType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("Age")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("AssessmentNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<int>("AssetId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("BuildingSelection")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("CeilingHeight")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Condition")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Conveniences")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("CreatedBy")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Date")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int?>("FloorNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FloorType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("LocalAuthority")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("LocalAuthorityCode")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("NewNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Notes")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ObsoleteNumber")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Occupier")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("OfficeGrade")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("OfficeSuite")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("Owner")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ParkingSpace")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("PropertySubCategory")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("PropertyType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<decimal?>("RentPM")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("RoadName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<decimal?>("SuggestedRate")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("Terms")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<decimal?>("TotalArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UpdatedBy")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("UsableFloorArea")
+                        .HasColumnType("decimal(18,2)");
+
+                    b.Property<string>("WallType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int?>("WardNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssetId");
+
+                    b.ToTable("OfficesRatingCards");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Asset", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Request", "Request")
+                        .WithMany()
+                        .HasForeignKey("RequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Request");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.AssetDivision", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.BuildingRatesLA", "BuildingRate")
+                        .WithMany()
+                        .HasForeignKey("BuildingRateId");
+
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BuildingRate");
+
+                    b.Navigation("Masterfile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.DomesticRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionBuilding", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.InspectionReport", "InspectionReport")
+                        .WithMany("Buildings")
+                        .HasForeignKey("InspectionReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("InspectionReport");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.PastValuationsLA", "PastValuation")
+                        .WithMany()
+                        .HasForeignKey("PastValuationId");
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("PastValuation");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.RentalEvidenceLA", "RentalEvidence")
+                        .WithMany()
+                        .HasForeignKey("RentalEvidenceId");
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("RentalEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.Request", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
+                        .WithMany()
+                        .HasForeignKey("RequestTypeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("RequestType");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+
+                    b.Navigation("Report");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.SalesEvidenceLA", "SalesEvidence")
+                        .WithMany()
+                        .HasForeignKey("SalesEvidenceId");
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("SalesEvidence");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.UserTask", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.iteration2.RatingCards.OfficesRatingCard", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.Asset", "Asset")
+                        .WithMany()
+                        .HasForeignKey("AssetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Asset");
+                });
+
+            modelBuilder.Entity("ValuationBackend.Models.InspectionReport", b =>
+                {
+                    b.Navigation("Buildings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Migrations/20250723061305_MakeEvidenceIdNullableInCoordinates.cs b/Migrations/20250723061305_MakeEvidenceIdNullableInCoordinates.cs
new file mode 100644
index 0000000..bcbcba9
--- /dev/null
+++ b/Migrations/20250723061305_MakeEvidenceIdNullableInCoordinates.cs
@@ -0,0 +1,182 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ValuationBackend.Migrations
+{
+    /// <inheritdoc />
+    public partial class MakeEvidenceIdNullableInCoordinates : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_BuildingRatesLACoordinates_BuildingRatesLA_BuildingRateId",
+                table: "BuildingRatesLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PastValuationsLACoordinates_PastValuationsLA_PastValuationId",
+                table: "PastValuationsLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_RentalEvidencesLA_RentalEvidenc~",
+                table: "RentalEvidenceLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_SalesEvidencesLA_SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "RentalEvidenceId",
+                table: "RentalEvidenceLACoordinates",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "PastValuationId",
+                table: "PastValuationsLACoordinates",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "BuildingRateId",
+                table: "BuildingRatesLACoordinates",
+                type: "integer",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "integer");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_BuildingRatesLACoordinates_BuildingRatesLA_BuildingRateId",
+                table: "BuildingRatesLACoordinates",
+                column: "BuildingRateId",
+                principalTable: "BuildingRatesLA",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PastValuationsLACoordinates_PastValuationsLA_PastValuationId",
+                table: "PastValuationsLACoordinates",
+                column: "PastValuationId",
+                principalTable: "PastValuationsLA",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_RentalEvidencesLA_RentalEvidenc~",
+                table: "RentalEvidenceLACoordinates",
+                column: "RentalEvidenceId",
+                principalTable: "RentalEvidencesLA",
+                principalColumn: "Id");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_SalesEvidencesLA_SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates",
+                column: "SalesEvidenceId",
+                principalTable: "SalesEvidencesLA",
+                principalColumn: "Id");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_BuildingRatesLACoordinates_BuildingRatesLA_BuildingRateId",
+                table: "BuildingRatesLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_PastValuationsLACoordinates_PastValuationsLA_PastValuationId",
+                table: "PastValuationsLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_RentalEvidencesLA_RentalEvidenc~",
+                table: "RentalEvidenceLACoordinates");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_SalesEvidencesLA_SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "RentalEvidenceId",
+                table: "RentalEvidenceLACoordinates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "PastValuationId",
+                table: "PastValuationsLACoordinates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "BuildingRateId",
+                table: "BuildingRatesLACoordinates",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_BuildingRatesLACoordinates_BuildingRatesLA_BuildingRateId",
+                table: "BuildingRatesLACoordinates",
+                column: "BuildingRateId",
+                principalTable: "BuildingRatesLA",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_PastValuationsLACoordinates_PastValuationsLA_PastValuationId",
+                table: "PastValuationsLACoordinates",
+                column: "PastValuationId",
+                principalTable: "PastValuationsLA",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_RentalEvidenceLACoordinates_RentalEvidencesLA_RentalEvidenc~",
+                table: "RentalEvidenceLACoordinates",
+                column: "RentalEvidenceId",
+                principalTable: "RentalEvidencesLA",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_SalesEvidenceLACoordinates_SalesEvidencesLA_SalesEvidenceId",
+                table: "SalesEvidenceLACoordinates",
+                column: "SalesEvidenceId",
+                principalTable: "SalesEvidencesLA",
+                principalColumn: "Id",
+                onDelete: ReferentialAction.Cascade);
+        }
+    }
+}
diff --git a/Migrations/AppDbContextModelSnapshot.cs b/Migrations/AppDbContextModelSnapshot.cs
index 42ecc90..23cfe2f 100644
--- a/Migrations/AppDbContextModelSnapshot.cs
+++ b/Migrations/AppDbContextModelSnapshot.cs
@@ -22,6 +22,34 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
 
+            modelBuilder.Entity("DecisionField", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Field")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("FieldDescription")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldSize")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FieldType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DecisionFields");
+                });
+
             modelBuilder.Entity("LandAquisitionMasterFile", b =>
                 {
                     b.Property<int>("Id")
@@ -331,9 +359,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("LocationLongitude")
                         .HasColumnType("text");
 
-                    b.Property<string>("MasterFileId")
-                        .IsRequired()
-                        .HasColumnType("text");
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
 
                     b.Property<string>("Owner")
                         .IsRequired()
@@ -358,11 +385,46 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("MasterFileId");
+
                     b.HasIndex("ReportId");
 
                     b.ToTable("BuildingRatesLA");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("BuildingRateId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BuildingRateId");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.ToTable("BuildingRatesLACoordinates");
+                });
+
             modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
                 {
                     b.Property<int>("Id")
@@ -818,6 +880,34 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("InspectionReports");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterFileId");
+
+                    b.ToTable("LALots");
+                });
+
             modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
                 {
                     b.Property<int>("Id")
@@ -841,6 +931,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("FloorArea")
                         .HasColumnType("text");
 
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
                     b.Property<string>("LocationLatitude")
                         .HasColumnType("text");
 
@@ -868,6 +961,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMBuildingRates_LandMiscellaneousMasterFileId");
+
                     b.HasIndex("ReportId");
 
                     b.ToTable("LMBuildingRates");
@@ -890,6 +986,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("FileNo_GnDivision")
                         .HasColumnType("text");
 
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
                     b.Property<string>("LocationLatitude")
                         .HasColumnType("text");
 
@@ -923,6 +1022,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMPastValuation_LandMiscellaneousMasterFileId");
+
                     b.HasIndex("ReportId");
 
                     b.ToTable("LMPastValuations");
@@ -948,6 +1050,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("HeadOfTerms")
                         .HasColumnType("text");
 
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
                     b.Property<string>("LocationLatitude")
                         .HasColumnType("text");
 
@@ -981,6 +1086,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMRentalEvidence_LandMiscellaneousMasterFileId");
+
                     b.HasIndex("ReportId");
 
                     b.ToTable("LMRentalEvidences");
@@ -1012,6 +1120,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("Extent")
                         .HasColumnType("text");
 
+                    b.Property<int?>("LandMiscellaneousMasterFileId")
+                        .HasColumnType("integer");
+
                     b.Property<string>("LandRegistryReferences")
                         .HasColumnType("text");
 
@@ -1063,6 +1174,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("LandMiscellaneousMasterFileId")
+                        .HasDatabaseName("IX_LMSalesEvidence_LandMiscellaneousMasterFileId");
+
                     b.HasIndex("ReportId");
 
                     b.ToTable("LMSalesEvidences");
@@ -1082,6 +1196,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<int>("MasterFileNo")
                         .HasColumnType("integer");
 
+                    b.Property<string>("MasterFileRefNo")
+                        .HasColumnType("text");
+
                     b.Property<string>("PlanNo")
                         .HasColumnType("text");
 
@@ -1120,6 +1237,27 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("MasterDataItems");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.PasswordReset", b =>
+            {
+                   b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Otp")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Used")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PasswordResets");
+                    });
+                    
             modelBuilder.Entity("ValuationBackend.Models.OfficesRatingCard", b =>
                 {
                     b.Property<int>("Id")
@@ -1128,6 +1266,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
 
+       
+
                     b.Property<string>("AccessType")
                         .HasColumnType("text");
 
@@ -1263,9 +1403,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("LocationLongitude")
                         .HasColumnType("text");
 
-                    b.Property<string>("MasterFileId")
-                        .IsRequired()
-                        .HasColumnType("text");
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
 
                     b.Property<string>("MasterFileRefNo")
                         .IsRequired()
@@ -1297,11 +1436,46 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("MasterFileId");
+
                     b.HasIndex("ReportId");
 
                     b.ToTable("PastValuationsLA");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("PastValuationId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("PastValuationId");
+
+                    b.ToTable("PastValuationsLACoordinates");
+                });
+
             modelBuilder.Entity("ValuationBackend.Models.PropertyCategory", b =>
                 {
                     b.Property<int>("Id")
@@ -1417,9 +1591,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("LocationLongitude")
                         .HasColumnType("text");
 
-                    b.Property<string>("MasterFileId")
-                        .IsRequired()
-                        .HasColumnType("text");
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
 
                     b.Property<string>("MasterFileRefNo")
                         .IsRequired()
@@ -1451,11 +1624,46 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("MasterFileId");
+
                     b.HasIndex("ReportId");
 
                     b.ToTable("RentalEvidencesLA", (string)null);
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("RentalEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("RentalEvidenceId");
+
+                    b.ToTable("RentalEvidenceLACoordinates");
+                });
+
             modelBuilder.Entity("ValuationBackend.Models.Report", b =>
                 {
                     b.Property<int>("ReportId")
@@ -1591,9 +1799,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("LotNumber")
                         .HasColumnType("text");
 
-                    b.Property<string>("MasterFileId")
-                        .IsRequired()
-                        .HasColumnType("text");
+                    b.Property<int>("MasterFileId")
+                        .HasColumnType("integer");
 
                     b.Property<string>("MasterFileRefNo")
                         .IsRequired()
@@ -1643,11 +1850,47 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("MasterFileId");
+
                     b.HasIndex("ReportId");
 
                     b.ToTable("SalesEvidencesLA", (string)null);
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Coordinates")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("MasterfileId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("SalesEvidenceId")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("UpdatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MasterfileId");
+
+                    b.HasIndex("SalesEvidenceId");
+
+                    b.ToTable("SalesEvidenceLACoordinates");
+                });
+
+   
             modelBuilder.Entity("ValuationBackend.Models.ShopsRatingCard", b =>
                 {
                     b.Property<int>("Id")
@@ -1997,15 +2240,40 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLA", b =>
                 {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
                     b.HasOne("ValuationBackend.Models.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("MasterFile");
+
                     b.Navigation("Report");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.BuildingRatesLACoordinate", b =>
+                {
+                    b.HasOne("ValuationBackend.Models.BuildingRatesLA", "BuildingRate")
+                        .WithMany()
+                        .HasForeignKey("BuildingRateId");
+
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BuildingRate");
+
+                    b.Navigation("Masterfile");
+                });
+
             modelBuilder.Entity("ValuationBackend.Models.ConditionReport", b =>
                 {
                     b.HasOne("ValuationBackend.Models.Report", "Report")
@@ -2050,47 +2318,86 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("Report");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.LALot", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MasterFile");
+                });
+
             modelBuilder.Entity("ValuationBackend.Models.LMBuildingRates", b =>
                 {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany()
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
                     b.HasOne("ValuationBackend.Models.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("LandMiscellaneousMasterFile");
+
                     b.Navigation("Report");
                 });
 
             modelBuilder.Entity("ValuationBackend.Models.LMPastValuation", b =>
                 {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany()
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
                     b.HasOne("ValuationBackend.Models.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("LandMiscellaneousMasterFile");
+
                     b.Navigation("Report");
                 });
 
             modelBuilder.Entity("ValuationBackend.Models.LMRentalEvidence", b =>
                 {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany()
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
                     b.HasOne("ValuationBackend.Models.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("LandMiscellaneousMasterFile");
+
                     b.Navigation("Report");
                 });
 
             modelBuilder.Entity("ValuationBackend.Models.LMSalesEvidence", b =>
                 {
+                    b.HasOne("ValuationBackend.Models.LandMiscellaneousMasterFile", "LandMiscellaneousMasterFile")
+                        .WithMany()
+                        .HasForeignKey("LandMiscellaneousMasterFileId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
                     b.HasOne("ValuationBackend.Models.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("LandMiscellaneousMasterFile");
+
                     b.Navigation("Report");
                 });
 
@@ -2107,15 +2414,40 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("ValuationBackend.Models.PastValuationsLA", b =>
                 {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
                     b.HasOne("ValuationBackend.Models.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("MasterFile");
+
                     b.Navigation("Report");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.PastValuationsLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.PastValuationsLA", "PastValuation")
+                        .WithMany()
+                        .HasForeignKey("PastValuationId");
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("PastValuation");
+                });
+
             modelBuilder.Entity("ValuationBackend.Models.Reconciliation", b =>
                 {
                     b.HasOne("ValuationBackend.Models.Asset", "Asset")
@@ -2129,15 +2461,40 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLA", b =>
                 {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
                     b.HasOne("ValuationBackend.Models.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("MasterFile");
+
                     b.Navigation("Report");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.RentalEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.RentalEvidenceLA", "RentalEvidence")
+                        .WithMany()
+                        .HasForeignKey("RentalEvidenceId");
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("RentalEvidence");
+                });
+
             modelBuilder.Entity("ValuationBackend.Models.Request", b =>
                 {
                     b.HasOne("ValuationBackend.Models.RequestType", "RequestType")
@@ -2151,15 +2508,39 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
             modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLA", b =>
                 {
+                    b.HasOne("LandAquisitionMasterFile", "MasterFile")
+                        .WithMany()
+                        .HasForeignKey("MasterFileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
                     b.HasOne("ValuationBackend.Models.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
 
+                    b.Navigation("MasterFile");
+
                     b.Navigation("Report");
                 });
 
+            modelBuilder.Entity("ValuationBackend.Models.SalesEvidenceLACoordinate", b =>
+                {
+                    b.HasOne("LandAquisitionMasterFile", "Masterfile")
+                        .WithMany()
+                        .HasForeignKey("MasterfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ValuationBackend.Models.SalesEvidenceLA", "SalesEvidence")
+                        .WithMany()
+                        .HasForeignKey("SalesEvidenceId");
+
+                    b.Navigation("Masterfile");
+
+                    b.Navigation("SalesEvidence");
+                    });
             modelBuilder.Entity("ValuationBackend.Models.ShopsRatingCard", b =>
                 {
                     b.HasOne("ValuationBackend.Models.Asset", "Asset")
diff --git a/Models/BuildingRatesLA.cs b/Models/BuildingRatesLA.cs
index 886757e..b25d3e2 100644
--- a/Models/BuildingRatesLA.cs
+++ b/Models/BuildingRatesLA.cs
@@ -17,7 +17,10 @@ public class BuildingRatesLA
         public Report? Report { get; set; }
         
         [Required]
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
+        
+        [ForeignKey("MasterFileId")]
+        public LandAquisitionMasterFile? MasterFile { get; set; }
         
         [Required]
         public string AssessmentNumber { get; set; } = string.Empty;
diff --git a/Models/DTOs/BuildingRatesLADtos.cs b/Models/DTOs/BuildingRatesLADtos.cs
index c6c367d..74603b9 100644
--- a/Models/DTOs/BuildingRatesLADtos.cs
+++ b/Models/DTOs/BuildingRatesLADtos.cs
@@ -6,7 +6,7 @@ namespace ValuationBackend.Models.DTOs
     public class BuildingRatesLACreateDto
     {
         // Master file information
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         
         public string? AssessmentNumber { get; set; }
         public string? Owner { get; set; }
@@ -24,7 +24,7 @@ public class BuildingRatesLACreateDto
     // Input DTO for updating an existing building rate
     public class BuildingRatesLAUpdateDto
     {
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         
         public string? AssessmentNumber { get; set; }
         public string? Owner { get; set; }
@@ -45,7 +45,7 @@ public class BuildingRatesLAResponseDto
         public int Id { get; set; }
         public int ReportId { get; set; }
         
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         
         public string? AssessmentNumber { get; set; }
         public string? Owner { get; set; }
diff --git a/Models/DTOs/LACoordinateDtos.cs b/Models/DTOs/LACoordinateDtos.cs
new file mode 100644
index 0000000..2b8f5fb
--- /dev/null
+++ b/Models/DTOs/LACoordinateDtos.cs
@@ -0,0 +1,140 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace ValuationBackend.Models.DTOs
+{
+    // PastValuationsLA Coordinate DTOs
+    public class PastValuationsLACoordinateCreateDto
+    {
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class PastValuationsLACoordinateUpdateDto
+    {
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [Required]
+        public int PastValuationId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class PastValuationsLACoordinateResponseDto
+    {
+        public int Id { get; set; }
+        public int MasterfileId { get; set; }
+        public int PastValuationId { get; set; }
+        public string Coordinates { get; set; } = string.Empty;
+        public DateTime CreatedAt { get; set; }
+        public DateTime? UpdatedAt { get; set; }
+    }
+
+    // BuildingRatesLA Coordinate DTOs
+    public class BuildingRatesLACoordinateCreateDto
+    {
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class BuildingRatesLACoordinateUpdateDto
+    {
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [Required]
+        public int BuildingRateId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class BuildingRatesLACoordinateResponseDto
+    {
+        public int Id { get; set; }
+        public int MasterfileId { get; set; }
+        public int BuildingRateId { get; set; }
+        public string Coordinates { get; set; } = string.Empty;
+        public DateTime CreatedAt { get; set; }
+        public DateTime? UpdatedAt { get; set; }
+    }
+
+    // SalesEvidenceLA Coordinate DTOs
+    public class SalesEvidenceLACoordinateCreateDto
+    {
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class SalesEvidenceLACoordinateUpdateDto
+    {
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [Required]
+        public int SalesEvidenceId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class SalesEvidenceLACoordinateResponseDto
+    {
+        public int Id { get; set; }
+        public int MasterfileId { get; set; }
+        public int SalesEvidenceId { get; set; }
+        public string Coordinates { get; set; } = string.Empty;
+        public DateTime CreatedAt { get; set; }
+        public DateTime? UpdatedAt { get; set; }
+    }
+
+    // RentalEvidenceLA Coordinate DTOs
+    public class RentalEvidenceLACoordinateCreateDto
+    {
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class RentalEvidenceLACoordinateUpdateDto
+    {
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [Required]
+        public int RentalEvidenceId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class RentalEvidenceLACoordinateResponseDto
+    {
+        public int Id { get; set; }
+        public int MasterfileId { get; set; }
+        public int RentalEvidenceId { get; set; }
+        public string Coordinates { get; set; } = string.Empty;
+        public DateTime CreatedAt { get; set; }
+        public DateTime? UpdatedAt { get; set; }
+    }
+}
diff --git a/Models/DTOs/LALotDtos.cs b/Models/DTOs/LALotDtos.cs
new file mode 100644
index 0000000..c9309a0
--- /dev/null
+++ b/Models/DTOs/LALotDtos.cs
@@ -0,0 +1,36 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace ValuationBackend.Models.DTOs
+{
+    public class LALotCreateDto
+    {
+        [Required]
+        public int MasterFileId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class LALotUpdateDto
+    {
+        [Required]
+        public int MasterFileId { get; set; }
+
+        [Required]
+        [MinLength(1, ErrorMessage = "Coordinates cannot be empty")]
+        public string Coordinates { get; set; } = string.Empty;
+    }
+
+    public class LALotResponseDto
+    {
+        public int Id { get; set; }
+        public int MasterFileId { get; set; }
+        public string Coordinates { get; set; } = string.Empty;
+        public DateTime CreatedAt { get; set; }
+        public DateTime? UpdatedAt { get; set; }
+        
+        // Optional: Include MasterFile details
+        public string MasterFileRefNo { get; set; } = string.Empty;
+    }
+}
diff --git a/Models/DTOs/LMBuildingRatesDtos.cs b/Models/DTOs/LMBuildingRatesDtos.cs
index cbc37ce..7fb7a80 100644
--- a/Models/DTOs/LMBuildingRatesDtos.cs
+++ b/Models/DTOs/LMBuildingRatesDtos.cs
@@ -17,6 +17,7 @@ public class LMBuildingRatesCreateDto
         public string? Remarks { get; set; }
         public string? LocationLatitude { get; set; }
         public string? LocationLongitude { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
     }
 
     public class LMBuildingRatesUpdateDto
@@ -36,6 +37,7 @@ public class LMBuildingRatesUpdateDto
         public string? Remarks { get; set; }
         public string? LocationLatitude { get; set; }
         public string? LocationLongitude { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
     }
 
     public class LMBuildingRatesResponseDto
@@ -54,5 +56,7 @@ public class LMBuildingRatesResponseDto
         public string? Remarks { get; set; }
         public string? LocationLatitude { get; set; }
         public string? LocationLongitude { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
+        public LandMiscellaneousMasterFileDto? LandMiscellaneousMasterFile { get; set; }
     }
 }
diff --git a/Models/DTOs/LMPastValuationDtos.cs b/Models/DTOs/LMPastValuationDtos.cs
index 70e952c..58afd7f 100644
--- a/Models/DTOs/LMPastValuationDtos.cs
+++ b/Models/DTOs/LMPastValuationDtos.cs
@@ -17,6 +17,7 @@ public class LMPastValuationCreateDto
         public string? Remarks { get; set; }
         public string? LocationLongitude { get; set; }
         public string? LocationLatitude { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
     }
 
     public class LMPastValuationUpdateDto
@@ -36,6 +37,7 @@ public class LMPastValuationUpdateDto
         public string? Remarks { get; set; }
         public string? LocationLongitude { get; set; }
         public string? LocationLatitude { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
     }
 
     public class LMPastValuationResponseDto
@@ -54,5 +56,7 @@ public class LMPastValuationResponseDto
         public string? Remarks { get; set; }
         public string? LocationLongitude { get; set; }
         public string? LocationLatitude { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
+        public LandMiscellaneousMasterFileDto? LandMiscellaneousMasterFile { get; set; }
     }
 }
diff --git a/Models/DTOs/LMRentalEvidenceDtos.cs b/Models/DTOs/LMRentalEvidenceDtos.cs
index 8c1ad4d..7255af6 100644
--- a/Models/DTOs/LMRentalEvidenceDtos.cs
+++ b/Models/DTOs/LMRentalEvidenceDtos.cs
@@ -6,6 +6,10 @@ public class LMRentalEvidenceCreateDto
     {
         [Required]
         public string MasterFileRefNo { get; set; }
+
+        // NEW: Optional foreign key to LandMiscellaneousMasterFile
+        public int? LandMiscellaneousMasterFileId { get; set; }
+
         public string? AssessmentNo { get; set; }
         public string? Owner { get; set; }
         public string? Occupier { get; set; }
@@ -26,6 +30,10 @@ public class LMRentalEvidenceUpdateDto
         public int ReportId { get; set; }
         [Required]
         public string MasterFileRefNo { get; set; }
+
+        // NEW: Optional foreign key to LandMiscellaneousMasterFile
+        public int? LandMiscellaneousMasterFileId { get; set; }
+
         public string? AssessmentNo { get; set; }
         public string? Owner { get; set; }
         public string? Occupier { get; set; }
@@ -45,6 +53,13 @@ public class LMRentalEvidenceResponseDto
         public int Id { get; set; }
         public int ReportId { get; set; }
         public string MasterFileRefNo { get; set; }
+
+        // NEW: Foreign key to LandMiscellaneousMasterFile
+        public int? LandMiscellaneousMasterFileId { get; set; }
+
+        // NEW: Navigation property for related master file data
+        public LandMiscellaneousMasterFileDto? LandMiscellaneousMasterFile { get; set; }
+
         public string? AssessmentNo { get; set; }
         public string? Owner { get; set; }
         public string? Occupier { get; set; }
@@ -58,4 +73,17 @@ public class LMRentalEvidenceResponseDto
         public string? Situation { get; set; }
         public string? Remarks { get; set; }
     }
+
+    // NEW: DTO for LandMiscellaneousMasterFile navigation property
+    public class LandMiscellaneousMasterFileDto
+    {
+        public int Id { get; set; }
+        public int MasterFileNo { get; set; }
+        public string? MasterFileRefNo { get; set; }
+        public string? PlanType { get; set; }
+        public string? PlanNo { get; set; }
+        public string? RequestingAuthorityReferenceNo { get; set; }
+        public string? Status { get; set; }
+        public int Lots { get; set; }
+    }
 }
diff --git a/Models/DTOs/LMSalesEvidenceDtos.cs b/Models/DTOs/LMSalesEvidenceDtos.cs
index a6ea5d6..a0d811e 100644
--- a/Models/DTOs/LMSalesEvidenceDtos.cs
+++ b/Models/DTOs/LMSalesEvidenceDtos.cs
@@ -26,6 +26,7 @@ public class LMSalesEvidenceCreateDto
         public string? LandRegistryReferences { get; set; }
         public string? Situation { get; set; }
         public string? DescriptionOfProperty { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
     }
 
     public class LMSalesEvidenceUpdateDto
@@ -54,6 +55,7 @@ public class LMSalesEvidenceUpdateDto
         public string? LandRegistryReferences { get; set; }
         public string? Situation { get; set; }
         public string? DescriptionOfProperty { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
     }
 
     public class LMSalesEvidenceResponseDto
@@ -81,5 +83,7 @@ public class LMSalesEvidenceResponseDto
         public string? LandRegistryReferences { get; set; }
         public string? Situation { get; set; }
         public string? DescriptionOfProperty { get; set; }
+        public int? LandMiscellaneousMasterFileId { get; set; }
+        public LandMiscellaneousMasterFileDto? LandMiscellaneousMasterFile { get; set; }
     }
 }
diff --git a/Models/DTOs/PastValuationsLADtos.cs b/Models/DTOs/PastValuationsLADtos.cs
index 943e21b..fb0c2c3 100644
--- a/Models/DTOs/PastValuationsLADtos.cs
+++ b/Models/DTOs/PastValuationsLADtos.cs
@@ -6,7 +6,7 @@ namespace ValuationBackend.Models.DTOs
     public class PastValuationsLACreateDto
     {
         // Master file information
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? FileNoGNDivision { get; set; }
@@ -25,7 +25,7 @@ public class PastValuationsLACreateDto
     // Input DTO for updating an existing past valuation record
     public class PastValuationsLAUpdateDto
     {
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? FileNoGNDivision { get; set; }
@@ -47,7 +47,7 @@ public class PastValuationsLAReadDto
         public int Id { get; set; }
         public int ReportId { get; set; }
         
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? FileNoGNDivision { get; set; }
diff --git a/Models/DTOs/RentalEvidenceLADtos.cs b/Models/DTOs/RentalEvidenceLADtos.cs
index 546544f..6710c13 100644
--- a/Models/DTOs/RentalEvidenceLADtos.cs
+++ b/Models/DTOs/RentalEvidenceLADtos.cs
@@ -6,7 +6,7 @@ namespace ValuationBackend.Models.DTOs
     public class RentalEvidenceLACreateDto
     {
         // Master file information
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? AssessmentNo { get; set; }
@@ -26,7 +26,7 @@ public class RentalEvidenceLACreateDto
     // Input DTO for updating an existing rental evidence
     public class RentalEvidenceLAUpdateDto
     {
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? AssessmentNo { get; set; }
@@ -49,7 +49,7 @@ public class RentalEvidenceLAResponseDto
         public int Id { get; set; }
         public int ReportId { get; set; }
         
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? AssessmentNo { get; set; }
diff --git a/Models/DTOs/SalesEvidenceLADtos.cs b/Models/DTOs/SalesEvidenceLADtos.cs
index cf38b0e..be628e3 100644
--- a/Models/DTOs/SalesEvidenceLADtos.cs
+++ b/Models/DTOs/SalesEvidenceLADtos.cs
@@ -6,7 +6,7 @@ namespace ValuationBackend.Models.DTOs
     public class SalesEvidenceLACreateDto
     {
         // Master file information
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? AssetNumber { get; set; }
@@ -38,7 +38,7 @@ public class SalesEvidenceLACreateDto
     // Input DTO for updating an existing sales evidence
     public class SalesEvidenceLAUpdateDto
     {
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? AssetNumber { get; set; }
@@ -73,7 +73,7 @@ public class SalesEvidenceLAResponseDto
         public int Id { get; set; }
         public int ReportId { get; set; }
         
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
         public string MasterFileRefNo { get; set; } = string.Empty;
         
         public string? AssetNumber { get; set; }
diff --git a/Models/LACoordinates.cs b/Models/LACoordinates.cs
new file mode 100644
index 0000000..5a64f8c
--- /dev/null
+++ b/Models/LACoordinates.cs
@@ -0,0 +1,117 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ValuationBackend.Models
+{
+    public class PastValuationsLACoordinate
+    {
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public int Id { get; set; } // Primary Key (auto increment)
+
+        // Foreign key to PastValuationsLA table (nullable to allow creation without evidence)
+        public int? PastValuationId { get; set; }
+
+        [ForeignKey("PastValuationId")]
+        public virtual PastValuationsLA? PastValuation { get; set; }
+
+        // Foreign key to LandAquisitionMasterFile table
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [ForeignKey("MasterfileId")]
+        public virtual LandAquisitionMasterFile? Masterfile { get; set; }
+
+        // Map coordinates from frontend (stored as JSON string)
+        [Required]
+        public string Coordinates { get; set; } = string.Empty;
+
+        // Optional: Additional metadata
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+        public DateTime? UpdatedAt { get; set; }
+    }
+
+    public class BuildingRatesLACoordinate
+    {
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public int Id { get; set; } // Primary Key (auto increment)
+
+        // Foreign key to BuildingRatesLA table (nullable to allow creation without evidence)
+        public int? BuildingRateId { get; set; }
+
+        [ForeignKey("BuildingRateId")]
+        public virtual BuildingRatesLA? BuildingRate { get; set; }
+
+        // Foreign key to LandAquisitionMasterFile table
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [ForeignKey("MasterfileId")]
+        public virtual LandAquisitionMasterFile? Masterfile { get; set; }
+
+        // Map coordinates from frontend (stored as JSON string)
+        [Required]
+        public string Coordinates { get; set; } = string.Empty;
+
+        // Optional: Additional metadata
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+        public DateTime? UpdatedAt { get; set; }
+    }
+
+    public class SalesEvidenceLACoordinate
+    {
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public int Id { get; set; } // Primary Key (auto increment)
+
+        // Foreign key to SalesEvidenceLA table (nullable to allow creation without evidence)
+        public int? SalesEvidenceId { get; set; }
+
+        [ForeignKey("SalesEvidenceId")]
+        public virtual SalesEvidenceLA? SalesEvidence { get; set; }
+
+        // Foreign key to LandAquisitionMasterFile table
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [ForeignKey("MasterfileId")]
+        public virtual LandAquisitionMasterFile? Masterfile { get; set; }
+
+        // Map coordinates from frontend (stored as JSON string)
+        [Required]
+        public string Coordinates { get; set; } = string.Empty;
+
+        // Optional: Additional metadata
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+        public DateTime? UpdatedAt { get; set; }
+    }
+
+    public class RentalEvidenceLACoordinate
+    {
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public int Id { get; set; } // Primary Key (auto increment)
+
+        // Foreign key to RentalEvidenceLA table (nullable to allow creation without evidence)
+        public int? RentalEvidenceId { get; set; }
+
+        [ForeignKey("RentalEvidenceId")]
+        public virtual RentalEvidenceLA? RentalEvidence { get; set; }
+
+        // Foreign key to LandAquisitionMasterFile table
+        [Required]
+        public int MasterfileId { get; set; }
+
+        [ForeignKey("MasterfileId")]
+        public virtual LandAquisitionMasterFile? Masterfile { get; set; }
+
+        // Map coordinates from frontend (stored as JSON string)
+        [Required]
+        public string Coordinates { get; set; } = string.Empty;
+
+        // Optional: Additional metadata
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+        public DateTime? UpdatedAt { get; set; }
+    }
+}
diff --git a/Models/LALot.cs b/Models/LALot.cs
new file mode 100644
index 0000000..0e50713
--- /dev/null
+++ b/Models/LALot.cs
@@ -0,0 +1,27 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ValuationBackend.Models
+{
+    public class LALot
+    {
+        [Key]
+        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+        public int Id { get; set; } // Primary Key (auto increment)
+
+        // Foreign key to LandAquisitionMasterFile table
+        [Required]
+        public int MasterFileId { get; set; }
+
+        [ForeignKey("MasterFileId")]
+        public virtual LandAquisitionMasterFile MasterFile { get; set; }
+
+        // Map coordinates from frontend (stored as JSON string)
+        [Required]
+        public string Coordinates { get; set; } = string.Empty;
+
+        // Optional: Additional metadata
+        public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+        public DateTime? UpdatedAt { get; set; }
+    }
+}
diff --git a/Models/LMBuildingRates.cs b/Models/LMBuildingRates.cs
index 8af4fff..93061c6 100644
--- a/Models/LMBuildingRates.cs
+++ b/Models/LMBuildingRates.cs
@@ -31,5 +31,11 @@ public class LMBuildingRates
         public string? Remarks { get; set; }
         public string? LocationLatitude { get; set; }
         public string? LocationLongitude { get; set; }
+
+        // Foreign key to LandMiscellaneousMasterFile table
+        public int? LandMiscellaneousMasterFileId { get; set; }
+
+        [ForeignKey("LandMiscellaneousMasterFileId")]
+        public virtual LandMiscellaneousMasterFile? LandMiscellaneousMasterFile { get; set; }
     }
 }
diff --git a/Models/LMPastValuation.cs b/Models/LMPastValuation.cs
index 358e295..16f3e3d 100644
--- a/Models/LMPastValuation.cs
+++ b/Models/LMPastValuation.cs
@@ -31,5 +31,11 @@ public class LMPastValuation
         public string? Remarks { get; set; }
         public string? LocationLongitude { get; set; }
         public string? LocationLatitude { get; set; }
+
+        // Foreign key to LandMiscellaneousMasterFile table
+        public int? LandMiscellaneousMasterFileId { get; set; }
+
+        [ForeignKey("LandMiscellaneousMasterFileId")]
+        public virtual LandMiscellaneousMasterFile? LandMiscellaneousMasterFile { get; set; }
     }
 }
diff --git a/Models/LMRentalEvidence.cs b/Models/LMRentalEvidence.cs
index d740a00..dec6747 100644
--- a/Models/LMRentalEvidence.cs
+++ b/Models/LMRentalEvidence.cs
@@ -14,10 +14,16 @@ public class LMRentalEvidence
         public int ReportId { get; set; }
 
         [ForeignKey("ReportId")]
-        public virtual Report Report { get; set; }
+        public virtual required Report Report { get; set; }
 
         [Required]
-        public string MasterFileRefNo { get; set; }
+        public required string MasterFileRefNo { get; set; }
+
+        // NEW: Add foreign key to LandMiscellaneousMasterFile
+        public int? LandMiscellaneousMasterFileId { get; set; }
+
+        [ForeignKey("LandMiscellaneousMasterFileId")]
+        public virtual LandMiscellaneousMasterFile? LandMiscellaneousMasterFile { get; set; }
 
         public string? AssessmentNo { get; set; }
         public string? Owner { get; set; }
diff --git a/Models/LMSalesEvidence.cs b/Models/LMSalesEvidence.cs
index 303da5d..a25b501 100644
--- a/Models/LMSalesEvidence.cs
+++ b/Models/LMSalesEvidence.cs
@@ -40,5 +40,11 @@ public class LMSalesEvidence
         public string? LandRegistryReferences { get; set; }
         public string? Situation { get; set; }
         public string? DescriptionOfProperty { get; set; }
+
+        // Foreign key to LandMiscellaneousMasterFile table
+        public int? LandMiscellaneousMasterFileId { get; set; }
+
+        [ForeignKey("LandMiscellaneousMasterFileId")]
+        public virtual LandMiscellaneousMasterFile? LandMiscellaneousMasterFile { get; set; }
     }
 }
diff --git a/Models/LandMiscellaneousMasterFile.cs b/Models/LandMiscellaneousMasterFile.cs
index ad6732e..75d97c8 100644
--- a/Models/LandMiscellaneousMasterFile.cs
+++ b/Models/LandMiscellaneousMasterFile.cs
@@ -6,6 +6,7 @@ public class LandMiscellaneousMasterFile
     {
         public int Id { get; set; }
         public int MasterFileNo { get; set; }
+        public string? MasterFileRefNo { get; set; }
         public string? PlanType { get; set; }
         public string? PlanNo { get; set; }
         public string? RequestingAuthorityReferenceNo { get; set; }
diff --git a/Models/PasswordReset.cs b/Models/PasswordReset.cs
new file mode 100644
index 0000000..9029ecc
--- /dev/null
+++ b/Models/PasswordReset.cs
@@ -0,0 +1,18 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace ValuationBackend.Models
+{
+    public class PasswordReset
+    {
+        [Key]
+        public int Id { get; set; }
+        [Required]
+        public string Email { get; set; }
+        [Required]
+        public string Otp { get; set; }
+        [Required]
+        public DateTime ExpiresAt { get; set; }
+        public bool Used { get; set; } = false;
+    }
+} 
\ No newline at end of file
diff --git a/Models/PastValuationsLA.cs b/Models/PastValuationsLA.cs
index fdfad8a..0b33e02 100644
--- a/Models/PastValuationsLA.cs
+++ b/Models/PastValuationsLA.cs
@@ -17,7 +17,10 @@ public class PastValuationsLA
         public Report? Report { get; set; }
         
         [Required]
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
+        
+        [ForeignKey("MasterFileId")]
+        public LandAquisitionMasterFile? MasterFile { get; set; }
         
         [Required]
         public string MasterFileRefNo { get; set; } = string.Empty;
diff --git a/Models/RentalEvidenceLA.cs b/Models/RentalEvidenceLA.cs
index 098365f..e1db648 100644
--- a/Models/RentalEvidenceLA.cs
+++ b/Models/RentalEvidenceLA.cs
@@ -17,7 +17,10 @@ public class RentalEvidenceLA
         public Report? Report { get; set; }
         
         [Required]
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
+        
+        [ForeignKey("MasterFileId")]
+        public LandAquisitionMasterFile? MasterFile { get; set; }
         
         public string? AssessmentNo { get; set; }
         
diff --git a/Models/SalesEvidenceLA.cs b/Models/SalesEvidenceLA.cs
index ca94d1c..2817802 100644
--- a/Models/SalesEvidenceLA.cs
+++ b/Models/SalesEvidenceLA.cs
@@ -17,7 +17,10 @@ public class SalesEvidenceLA
         public Report? Report { get; set; }
         
         [Required]
-        public string MasterFileId { get; set; } = string.Empty;
+        public int MasterFileId { get; set; }
+        
+        [ForeignKey("MasterFileId")]
+        public LandAquisitionMasterFile? MasterFile { get; set; }
         
         [Required]
         public string MasterFileRefNo { get; set; } = string.Empty;
diff --git a/Models/iteration2/DTOs/ObsoleteNumberDto.cs b/Models/iteration2/DTOs/ObsoleteNumberDto.cs
new file mode 100644
index 0000000..052669c
--- /dev/null
+++ b/Models/iteration2/DTOs/ObsoleteNumberDto.cs
@@ -0,0 +1,5 @@
+public class ObsoleteNumberDto
+{
+    public string Id { get; set; }
+    public string Number { get; set; }
+}
diff --git a/Models/iteration2/DTOs/streets.cs b/Models/iteration2/DTOs/streets.cs
new file mode 100644
index 0000000..0339563
--- /dev/null
+++ b/Models/iteration2/DTOs/streets.cs
@@ -0,0 +1,5 @@
+public class StreetDto
+{
+    public string Id { get; set; }
+    public string Name { get; set; }
+}
diff --git a/Models/iteration2/Decision.cs b/Models/iteration2/Decision.cs
new file mode 100644
index 0000000..96f60eb
--- /dev/null
+++ b/Models/iteration2/Decision.cs
@@ -0,0 +1,8 @@
+public class DecisionField
+{
+    public int Id { get; set; }
+    public string Field { get; set; }              // E.g., "Zone"
+    public string FieldDescription { get; set; }   // E.g., "Zoning Category"
+    public string FieldType { get; set; }          // E.g., "string", "number"
+    public int FieldSize { get; set; }             // E.g., 255
+}
diff --git a/NeondbContext.cs b/NeondbContext.cs
new file mode 100644
index 0000000..91c5c7b
--- /dev/null
+++ b/NeondbContext.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore;
+
+namespace ValuationBackend;
+
+public partial class NeondbContext : DbContext
+{
+    public NeondbContext(DbContextOptions<NeondbContext> options)
+        : base(options)
+    {
+    }
+
+    public virtual DbSet<PastValuationsLa> PastValuationsLas { get; set; }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.Entity<PastValuationsLa>(entity =>
+        {
+            entity.HasKey(e => e.Id).HasName("PK_PastValuationsLA_temp");
+
+            entity.ToTable("PastValuationsLA");
+
+            entity.HasIndex(e => e.MasterFileId, "IX_PastValuationsLA_MasterFileId");
+
+            entity.HasIndex(e => e.ReportId, "IX_PastValuationsLA_ReportId");
+
+            entity.Property(e => e.FileNoGndivision).HasColumnName("FileNoGNDivision");
+        });
+
+        OnModelCreatingPartial(modelBuilder);
+    }
+
+    partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
+}
diff --git a/PastValuationsLa.cs b/PastValuationsLa.cs
new file mode 100644
index 0000000..74e5030
--- /dev/null
+++ b/PastValuationsLa.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+
+namespace ValuationBackend;
+
+public partial class PastValuationsLa
+{
+    public int Id { get; set; }
+
+    public int ReportId { get; set; }
+
+    public string MasterFileRefNo { get; set; } = null!;
+
+    public string? FileNoGndivision { get; set; }
+
+    public string? Situation { get; set; }
+
+    public string? DateOfValuation { get; set; }
+
+    public string? PurposeOfValuation { get; set; }
+
+    public string? PlanOfParticulars { get; set; }
+
+    public string? Extent { get; set; }
+
+    public string? Rate { get; set; }
+
+    public string? RateType { get; set; }
+
+    public string? Remarks { get; set; }
+
+    public string? LocationLongitude { get; set; }
+
+    public string? LocationLatitude { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public int MasterFileId { get; set; }
+}
diff --git a/Profiles/LACoordinateProfiles.cs b/Profiles/LACoordinateProfiles.cs
new file mode 100644
index 0000000..9610127
--- /dev/null
+++ b/Profiles/LACoordinateProfiles.cs
@@ -0,0 +1,76 @@
+using AutoMapper;
+using ValuationBackend.Models;
+using ValuationBackend.Models.DTOs;
+
+namespace ValuationBackend.Profiles
+{
+    public class LACoordinateProfiles : Profile
+    {
+        public LACoordinateProfiles()
+        {
+            // PastValuationsLA Coordinate Mappings
+            CreateMap<PastValuationsLACoordinate, PastValuationsLACoordinateResponseDto>();
+            CreateMap<PastValuationsLACoordinateCreateDto, PastValuationsLACoordinate>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.PastValuationId, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.PastValuation, opt => opt.Ignore())
+                .ForMember(dest => dest.Masterfile, opt => opt.Ignore());
+            CreateMap<PastValuationsLACoordinateUpdateDto, PastValuationsLACoordinate>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.PastValuation, opt => opt.Ignore())
+                .ForMember(dest => dest.Masterfile, opt => opt.Ignore());
+
+            // BuildingRatesLA Coordinate Mappings
+            CreateMap<BuildingRatesLACoordinate, BuildingRatesLACoordinateResponseDto>();
+            CreateMap<BuildingRatesLACoordinateCreateDto, BuildingRatesLACoordinate>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.BuildingRateId, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.BuildingRate, opt => opt.Ignore())
+                .ForMember(dest => dest.Masterfile, opt => opt.Ignore());
+            CreateMap<BuildingRatesLACoordinateUpdateDto, BuildingRatesLACoordinate>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.BuildingRate, opt => opt.Ignore())
+                .ForMember(dest => dest.Masterfile, opt => opt.Ignore());
+
+            // SalesEvidenceLA Coordinate Mappings
+            CreateMap<SalesEvidenceLACoordinate, SalesEvidenceLACoordinateResponseDto>();
+            CreateMap<SalesEvidenceLACoordinateCreateDto, SalesEvidenceLACoordinate>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.SalesEvidenceId, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.SalesEvidence, opt => opt.Ignore())
+                .ForMember(dest => dest.Masterfile, opt => opt.Ignore());
+            CreateMap<SalesEvidenceLACoordinateUpdateDto, SalesEvidenceLACoordinate>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.SalesEvidence, opt => opt.Ignore())
+                .ForMember(dest => dest.Masterfile, opt => opt.Ignore());
+
+            // RentalEvidenceLA Coordinate Mappings
+            CreateMap<RentalEvidenceLACoordinate, RentalEvidenceLACoordinateResponseDto>();
+            CreateMap<RentalEvidenceLACoordinateCreateDto, RentalEvidenceLACoordinate>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.RentalEvidenceId, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.RentalEvidence, opt => opt.Ignore())
+                .ForMember(dest => dest.Masterfile, opt => opt.Ignore());
+            CreateMap<RentalEvidenceLACoordinateUpdateDto, RentalEvidenceLACoordinate>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.RentalEvidence, opt => opt.Ignore())
+                .ForMember(dest => dest.Masterfile, opt => opt.Ignore());
+        }
+    }
+}
diff --git a/Profiles/LALotProfile.cs b/Profiles/LALotProfile.cs
new file mode 100644
index 0000000..43b3585
--- /dev/null
+++ b/Profiles/LALotProfile.cs
@@ -0,0 +1,30 @@
+using AutoMapper;
+using ValuationBackend.Models;
+using ValuationBackend.Models.DTOs;
+
+namespace ValuationBackend.Profiles
+{
+    public class LALotProfile : Profile
+    {
+        public LALotProfile()
+        {
+            // Entity to DTO
+            CreateMap<LALot, LALotResponseDto>()
+                .ForMember(dest => dest.MasterFileRefNo, opt => opt.MapFrom(src => src.MasterFile.MasterFilesRefNo));
+
+            // Create DTO to Entity
+            CreateMap<LALotCreateDto, LALot>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.MasterFile, opt => opt.Ignore());
+
+            // Update DTO to Entity
+            CreateMap<LALotUpdateDto, LALot>()
+                .ForMember(dest => dest.Id, opt => opt.Ignore())
+                .ForMember(dest => dest.CreatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.UpdatedAt, opt => opt.Ignore())
+                .ForMember(dest => dest.MasterFile, opt => opt.Ignore());
+        }
+    }
+}
diff --git a/Program.cs b/Program.cs
index 71407b2..1159336 100644
--- a/Program.cs
+++ b/Program.cs
@@ -7,6 +7,7 @@
 using ValuationBackend.Extensions;
 using ValuationBackend.Models;
 using DotNetEnv;
+using ValuationBackend.Services;
 
 // Load environment variables from .env file
 Env.Load();
@@ -32,6 +33,8 @@
 // Register repositories and services using extension methods
 builder.Services.AddRepositories();
 builder.Services.AddServices();
+builder.Services.AddScoped<IEmailSender, EmailSender>();
+builder.Services.AddScoped<PasswordResetService>();
 
 
 // Configure PostgreSQL
@@ -65,6 +68,10 @@
     options.ExpiryMinutes = jwtSettings.ExpiryMinutes;
 });
 
+builder.Services.AddDbContext<ValuationContext>(options =>
+    options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));
+
+
 // Add Authentication
 var key = Encoding.UTF8.GetBytes(jwtSettings.SecretKey);
 builder.Services.AddAuthentication(options =>
@@ -106,6 +113,16 @@
     try
     {
         var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
+
+        // Only reset database if explicitly requested (e.g., via environment variable)
+        var shouldResetDb = Environment.GetEnvironmentVariable("RESET_DATABASE")?.ToLower() == "true";
+
+        if (shouldResetDb)
+        {
+            Console.WriteLine("Resetting database...");
+            // Add database reset logic here if needed
+        }
+
         DbInitializer.Initialize(dbContext);
         Console.WriteLine("Database initialized successfully.");
     }
diff --git a/SORTING_API_DOCUMENTATION.md b/SORTING_API_DOCUMENTATION.md
deleted file mode 100644
index 00608ea..0000000
--- a/SORTING_API_DOCUMENTATION.md
+++ /dev/null
@@ -1,85 +0,0 @@
-# Land Miscellaneous API - Sorting Documentation
-
-## Overview
-
-The Land Miscellaneous API endpoints now support sorting functionality. All sorting is performed in ascending order.
-
-## Available Endpoints with Sorting
-
-### 1. Get All Records with Sorting
-
-```
-GET /api/landmiscellaneous/all?sortBy={field}
-```
-
-### 2. Get Paginated Records with Sorting
-
-```
-GET /api/landmiscellaneous/paginated?pageNumber={number}&pageSize={size}&sortBy={field}
-```
-
-### 3. Search Records with Sorting
-
-```
-GET /api/landmiscellaneous/search?searchTerm={term}&pageNumber={number}&pageSize={size}&sortBy={field}
-```
-
-## Sortable Fields
-
-| Field Name                        | API Parameter                    | Description                             |
-| --------------------------------- | -------------------------------- | --------------------------------------- |
-| ID                                | `id`                             | Primary key                             |
-| Master File No                    | `masterfileno`                   | Master file number                      |
-| Plan Type                         | `plantype`                       | Type of plan (PP, Cadaster, FVP, etc.)  |
-| Plan No                           | `planno`                         | Plan number                             |
-| Requesting Authority Reference No | `requestingauthorityreferenceno` | Reference number                        |
-| Status                            | `status`                         | Current status (Success, Pending, etc.) |
-
-## Sort Direction
-
-All sorting is performed in **ascending order only**.
-
-## Examples
-
-### Sort by Master File Number
-
-```
-GET /api/landmiscellaneous/paginated?sortBy=masterfileno
-```
-
-### Sort by Status
-
-```
-GET /api/landmiscellaneous/all?sortBy=status
-```
-
-### Search with Sorting by Plan Type
-
-```
-GET /api/landmiscellaneous/search?searchTerm=PP&sortBy=plantype&pageNumber=1&pageSize=10
-```
-
-## Default Behavior
-
-- If no `sortBy` parameter is provided, records are sorted by `Id` in ascending order
-- If an invalid `sortBy` field is provided, it defaults to sorting by `Id`
-- All sorting is performed in ascending order only
-
-## Response Format
-
-All responses include the sorting parameter in the response:
-
-```json
-{
-  "Records": [...],
-  "TotalCount": 100,
-  "PageNumber": 1,
-  "PageSize": 10,
-  "TotalPages": 10,
-  "SortBy": "masterfileno"
-}
-```
-
-## Backward Compatibility
-
-All existing API calls will continue to work without any changes. The sorting parameter is optional and has sensible defaults.
diff --git a/repositories/DecisionFieldRepository.cs b/repositories/DecisionFieldRepository.cs
new file mode 100644
index 0000000..219e17a
--- /dev/null
+++ b/repositories/DecisionFieldRepository.cs
@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using ValuationBackend.Data;
+using ValuationBackend.Models;
+
+namespace ValuationBackend.Repositories
+{
+    public class DecisionFieldRepository
+    {
+        private readonly ValuationContext _context;
+
+        public DecisionFieldRepository(ValuationContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<DecisionField>> GetAllAsync()
+        {
+            return await _context.DecisionFields.ToListAsync();
+        }
+
+        public async Task<DecisionField> AddAsync(DecisionField field)
+        {
+            _context.DecisionFields.Add(field);
+            await _context.SaveChangesAsync();
+            return field;
+        }
+
+        // Add more methods as needed (e.g., GetByIdAsync, UpdateAsync, DeleteAsync)
+    }
+}
diff --git a/repositories/ILACoordinateRepositories.cs b/repositories/ILACoordinateRepositories.cs
new file mode 100644
index 0000000..83f26df
--- /dev/null
+++ b/repositories/ILACoordinateRepositories.cs
@@ -0,0 +1,66 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models;
+
+namespace ValuationBackend.Repositories
+{
+    // PastValuationsLA Coordinate Repository
+    public interface IPastValuationsLACoordinateRepository
+    {
+        Task<IEnumerable<PastValuationsLACoordinate>> GetAllAsync();
+        Task<PastValuationsLACoordinate> GetByIdAsync(int id);
+        Task<IEnumerable<PastValuationsLACoordinate>> GetByPastValuationIdAsync(int pastValuationId);
+        Task<IEnumerable<PastValuationsLACoordinate>> GetByMasterfileIdAsync(int masterfileId);
+        Task<PastValuationsLACoordinate> CreateAsync(PastValuationsLACoordinate coordinate);
+        Task<bool> UpdateAsync(PastValuationsLACoordinate coordinate);
+        Task<bool> DeleteAsync(int id);
+        Task<bool> ExistsAsync(int id);
+        Task<bool> PastValuationExistsAsync(int pastValuationId);
+        Task<bool> MasterFileExistsAsync(int masterFileId);
+    }
+
+    // BuildingRatesLA Coordinate Repository
+    public interface IBuildingRatesLACoordinateRepository
+    {
+        Task<IEnumerable<BuildingRatesLACoordinate>> GetAllAsync();
+        Task<BuildingRatesLACoordinate> GetByIdAsync(int id);
+        Task<IEnumerable<BuildingRatesLACoordinate>> GetByBuildingRateIdAsync(int buildingRateId);
+        Task<IEnumerable<BuildingRatesLACoordinate>> GetByMasterfileIdAsync(int masterfileId);
+        Task<BuildingRatesLACoordinate> CreateAsync(BuildingRatesLACoordinate coordinate);
+        Task<bool> UpdateAsync(BuildingRatesLACoordinate coordinate);
+        Task<bool> DeleteAsync(int id);
+        Task<bool> ExistsAsync(int id);
+        Task<bool> BuildingRateExistsAsync(int buildingRateId);
+        Task<bool> MasterFileExistsAsync(int masterFileId);
+    }
+
+    // SalesEvidenceLA Coordinate Repository
+    public interface ISalesEvidenceLACoordinateRepository
+    {
+        Task<IEnumerable<SalesEvidenceLACoordinate>> GetAllAsync();
+        Task<SalesEvidenceLACoordinate> GetByIdAsync(int id);
+        Task<IEnumerable<SalesEvidenceLACoordinate>> GetBySalesEvidenceIdAsync(int salesEvidenceId);
+        Task<IEnumerable<SalesEvidenceLACoordinate>> GetByMasterfileIdAsync(int masterfileId);
+        Task<SalesEvidenceLACoordinate> CreateAsync(SalesEvidenceLACoordinate coordinate);
+        Task<bool> UpdateAsync(SalesEvidenceLACoordinate coordinate);
+        Task<bool> DeleteAsync(int id);
+        Task<bool> ExistsAsync(int id);
+        Task<bool> SalesEvidenceExistsAsync(int salesEvidenceId);
+        Task<bool> MasterFileExistsAsync(int masterFileId);
+    }
+
+    // RentalEvidenceLA Coordinate Repository
+    public interface IRentalEvidenceLACoordinateRepository
+    {
+        Task<IEnumerable<RentalEvidenceLACoordinate>> GetAllAsync();
+        Task<RentalEvidenceLACoordinate> GetByIdAsync(int id);
+        Task<IEnumerable<RentalEvidenceLACoordinate>> GetByRentalEvidenceIdAsync(int rentalEvidenceId);
+        Task<IEnumerable<RentalEvidenceLACoordinate>> GetByMasterfileIdAsync(int masterfileId);
+        Task<RentalEvidenceLACoordinate> CreateAsync(RentalEvidenceLACoordinate coordinate);
+        Task<bool> UpdateAsync(RentalEvidenceLACoordinate coordinate);
+        Task<bool> DeleteAsync(int id);
+        Task<bool> ExistsAsync(int id);
+        Task<bool> RentalEvidenceExistsAsync(int rentalEvidenceId);
+        Task<bool> MasterFileExistsAsync(int masterFileId);
+    }
+}
diff --git a/repositories/ILALotRepository.cs b/repositories/ILALotRepository.cs
new file mode 100644
index 0000000..14d8fb8
--- /dev/null
+++ b/repositories/ILALotRepository.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models;
+
+namespace ValuationBackend.Repositories
+{
+    public interface ILALotRepository
+    {
+        Task<IEnumerable<LALot>> GetAllAsync();
+        Task<LALot> GetByIdAsync(int id);
+        Task<IEnumerable<LALot>> GetByMasterFileIdAsync(int masterFileId);
+        Task<LALot> CreateAsync(LALot laLot);
+        Task<bool> UpdateAsync(LALot laLot);
+        Task<bool> DeleteAsync(int id);
+        Task<bool> ExistsAsync(int id);
+        Task<bool> MasterFileExistsAsync(int masterFileId);
+    }
+}
diff --git a/repositories/ILMBuildingRatesRepository.cs b/repositories/ILMBuildingRatesRepository.cs
index 79e085f..de54e34 100644
--- a/repositories/ILMBuildingRatesRepository.cs
+++ b/repositories/ILMBuildingRatesRepository.cs
@@ -8,6 +8,8 @@ public interface ILMBuildingRatesRepository
     {
         Task<IEnumerable<LMBuildingRates>> GetAllAsync();
         Task<LMBuildingRates> GetByIdAsync(int id);
+        Task<LMBuildingRates> GetByIdWithMasterFileAsync(int id);
+        Task<IEnumerable<LMBuildingRates>> GetByMasterFileIdAsync(int masterFileId);
         Task<LMBuildingRates> GetByReportIdAsync(int reportId);
         Task<Report> CreateReportAsync(Report report);
         Task<LMBuildingRates> CreateAsync(LMBuildingRates lmBuildingRate);
diff --git a/repositories/ILMPastValuationRepository.cs b/repositories/ILMPastValuationRepository.cs
index bace7ef..d555f12 100644
--- a/repositories/ILMPastValuationRepository.cs
+++ b/repositories/ILMPastValuationRepository.cs
@@ -8,6 +8,8 @@ public interface ILMPastValuationRepository
     {
         Task<IEnumerable<LMPastValuation>> GetAllAsync();
         Task<LMPastValuation> GetByIdAsync(int id);
+        Task<LMPastValuation> GetByIdWithMasterFileAsync(int id);
+        Task<IEnumerable<LMPastValuation>> GetByMasterFileIdAsync(int masterFileId);
         Task<LMPastValuation> GetByReportIdAsync(int reportId);
         Task<Report> CreateReportAsync(Report report);
         Task<LMPastValuation> CreateAsync(LMPastValuation lmPastValuation);
diff --git a/repositories/ILMRentalEvidenceRepository.cs b/repositories/ILMRentalEvidenceRepository.cs
index 26e5bdd..077f2ae 100644
--- a/repositories/ILMRentalEvidenceRepository.cs
+++ b/repositories/ILMRentalEvidenceRepository.cs
@@ -9,6 +9,13 @@ public interface ILMRentalEvidenceRepository
         Task<IEnumerable<LMRentalEvidence>> GetAllAsync();
         Task<LMRentalEvidence> GetByIdAsync(int id);
         Task<LMRentalEvidence> GetByReportIdAsync(int reportId);
+
+        // NEW: Methods for foreign key relationship
+        Task<IEnumerable<LMRentalEvidence>> GetByMasterFileIdAsync(int masterFileId);
+        Task<IEnumerable<LMRentalEvidence>> GetByMasterFileRefNoAsync(string masterFileRefNo);
+        Task<IEnumerable<LMRentalEvidence>> GetAllWithMasterFileDataAsync();
+        Task<LandMiscellaneousMasterFile?> GetMasterFileByRefNoAsync(string refNo);
+
         Task<Report> CreateReportAsync(Report report);
         Task<LMRentalEvidence> CreateAsync(LMRentalEvidence lmRentalEvidence);
         Task<bool> UpdateAsync(LMRentalEvidence lmRentalEvidence);
diff --git a/repositories/ILMSalesEvidenceRepository.cs b/repositories/ILMSalesEvidenceRepository.cs
index 40f1854..f5560df 100644
--- a/repositories/ILMSalesEvidenceRepository.cs
+++ b/repositories/ILMSalesEvidenceRepository.cs
@@ -8,6 +8,8 @@ public interface ILMSalesEvidenceRepository
     {
         Task<IEnumerable<LMSalesEvidence>> GetAllAsync();
         Task<LMSalesEvidence> GetByIdAsync(int id);
+        Task<LMSalesEvidence> GetByIdWithMasterFileAsync(int id);
+        Task<IEnumerable<LMSalesEvidence>> GetByMasterFileIdAsync(int masterFileId);
         Task<LMSalesEvidence> GetByReportIdAsync(int reportId);
         Task<Report> CreateReportAsync(Report report);
         Task<LMSalesEvidence> CreateAsync(LMSalesEvidence lmSalesEvidence);
diff --git a/repositories/ILandMiscellaneousRepository.cs b/repositories/ILandMiscellaneousRepository.cs
index 64733e7..8c81de6 100644
--- a/repositories/ILandMiscellaneousRepository.cs
+++ b/repositories/ILandMiscellaneousRepository.cs
@@ -13,5 +13,8 @@ public interface ILandMiscellaneousRepository
 
         Task<List<LandMiscellaneousMasterFile>> SearchAsync(string searchTerm, int pageNumber, int pageSize, string sortBy = "", int? assignedToUserId = null);
         Task<int> GetSearchCountAsync(string searchTerm, int? assignedToUserId = null);
+
+        // NEW: Method for foreign key support
+        Task<LandMiscellaneousMasterFile?> GetByRefNoAsync(string refNo);
     }
 }
diff --git a/repositories/LACoordinateRepositories.cs b/repositories/LACoordinateRepositories.cs
new file mode 100644
index 0000000..ff52f62
--- /dev/null
+++ b/repositories/LACoordinateRepositories.cs
@@ -0,0 +1,413 @@
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ValuationBackend.Data;
+using ValuationBackend.Models;
+
+namespace ValuationBackend.Repositories
+{
+    // PastValuationsLA Coordinate Repository
+    public class PastValuationsLACoordinateRepository : IPastValuationsLACoordinateRepository
+    {
+        private readonly AppDbContext _context;
+
+        public PastValuationsLACoordinateRepository(AppDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<PastValuationsLACoordinate>> GetAllAsync()
+        {
+            return await _context.PastValuationsLACoordinates
+                .Include(c => c.PastValuation)
+                .Include(c => c.Masterfile)
+                .ToListAsync();
+        }
+
+        public async Task<PastValuationsLACoordinate> GetByIdAsync(int id)
+        {
+            return await _context.PastValuationsLACoordinates
+                .Include(c => c.PastValuation)
+                .Include(c => c.Masterfile)
+                .FirstOrDefaultAsync(c => c.Id == id);
+        }
+
+        public async Task<IEnumerable<PastValuationsLACoordinate>> GetByPastValuationIdAsync(int pastValuationId)
+        {
+            return await _context.PastValuationsLACoordinates
+                .Include(c => c.PastValuation)
+                .Include(c => c.Masterfile)
+                .Where(c => c.PastValuationId == pastValuationId)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<PastValuationsLACoordinate>> GetByMasterfileIdAsync(int masterfileId)
+        {
+            return await _context.PastValuationsLACoordinates
+                .Include(c => c.PastValuation)
+                .Include(c => c.Masterfile)
+                .Where(c => c.MasterfileId == masterfileId)
+                .ToListAsync();
+        }
+
+        public async Task<PastValuationsLACoordinate> CreateAsync(PastValuationsLACoordinate coordinate)
+        {
+            coordinate.CreatedAt = DateTime.UtcNow;
+            _context.PastValuationsLACoordinates.Add(coordinate);
+            await _context.SaveChangesAsync();
+            
+            await _context.Entry(coordinate)
+                .Reference(c => c.PastValuation)
+                .LoadAsync();
+                
+            return coordinate;
+        }
+
+        public async Task<bool> UpdateAsync(PastValuationsLACoordinate coordinate)
+        {
+            try
+            {
+                coordinate.UpdatedAt = DateTime.UtcNow;
+                _context.Entry(coordinate).State = EntityState.Modified;
+                await _context.SaveChangesAsync();
+                return true;
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                return false;
+            }
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            var coordinate = await _context.PastValuationsLACoordinates.FindAsync(id);
+            if (coordinate == null)
+            {
+                return false;
+            }
+
+            _context.PastValuationsLACoordinates.Remove(coordinate);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        public async Task<bool> ExistsAsync(int id)
+        {
+            return await _context.PastValuationsLACoordinates.AnyAsync(c => c.Id == id);
+        }
+
+        public async Task<bool> PastValuationExistsAsync(int pastValuationId)
+        {
+            return await _context.PastValuationsLA.AnyAsync(p => p.Id == pastValuationId);
+        }
+
+        public async Task<bool> MasterFileExistsAsync(int masterFileId)
+        {
+            return await _context.LandAquisitionMasterFiles.AnyAsync(m => m.Id == masterFileId);
+        }
+    }
+
+    // BuildingRatesLA Coordinate Repository
+    public class BuildingRatesLACoordinateRepository : IBuildingRatesLACoordinateRepository
+    {
+        private readonly AppDbContext _context;
+
+        public BuildingRatesLACoordinateRepository(AppDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<BuildingRatesLACoordinate>> GetAllAsync()
+        {
+            return await _context.BuildingRatesLACoordinates
+                .Include(c => c.BuildingRate)
+                .Include(c => c.Masterfile)
+                .ToListAsync();
+        }
+
+        public async Task<BuildingRatesLACoordinate> GetByIdAsync(int id)
+        {
+            return await _context.BuildingRatesLACoordinates
+                .Include(c => c.BuildingRate)
+                .Include(c => c.Masterfile)
+                .FirstOrDefaultAsync(c => c.Id == id);
+        }
+
+        public async Task<IEnumerable<BuildingRatesLACoordinate>> GetByBuildingRateIdAsync(int buildingRateId)
+        {
+            return await _context.BuildingRatesLACoordinates
+                .Include(c => c.BuildingRate)
+                .Include(c => c.Masterfile)
+                .Where(c => c.BuildingRateId == buildingRateId)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<BuildingRatesLACoordinate>> GetByMasterfileIdAsync(int masterfileId)
+        {
+            return await _context.BuildingRatesLACoordinates
+                .Include(c => c.BuildingRate)
+                .Include(c => c.Masterfile)
+                .Where(c => c.MasterfileId == masterfileId)
+                .ToListAsync();
+        }
+
+        public async Task<BuildingRatesLACoordinate> CreateAsync(BuildingRatesLACoordinate coordinate)
+        {
+            coordinate.CreatedAt = DateTime.UtcNow;
+            _context.BuildingRatesLACoordinates.Add(coordinate);
+            await _context.SaveChangesAsync();
+            
+            await _context.Entry(coordinate)
+                .Reference(c => c.BuildingRate)
+                .LoadAsync();
+                
+            return coordinate;
+        }
+
+        public async Task<bool> UpdateAsync(BuildingRatesLACoordinate coordinate)
+        {
+            try
+            {
+                coordinate.UpdatedAt = DateTime.UtcNow;
+                _context.Entry(coordinate).State = EntityState.Modified;
+                await _context.SaveChangesAsync();
+                return true;
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                return false;
+            }
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            var coordinate = await _context.BuildingRatesLACoordinates.FindAsync(id);
+            if (coordinate == null)
+            {
+                return false;
+            }
+
+            _context.BuildingRatesLACoordinates.Remove(coordinate);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        public async Task<bool> ExistsAsync(int id)
+        {
+            return await _context.BuildingRatesLACoordinates.AnyAsync(c => c.Id == id);
+        }
+
+        public async Task<bool> BuildingRateExistsAsync(int buildingRateId)
+        {
+            return await _context.BuildingRatesLA.AnyAsync(b => b.Id == buildingRateId);
+        }
+
+        public async Task<bool> MasterFileExistsAsync(int masterFileId)
+        {
+            return await _context.LandAquisitionMasterFiles.AnyAsync(m => m.Id == masterFileId);
+        }
+    }
+
+    // SalesEvidenceLA Coordinate Repository
+    public class SalesEvidenceLACoordinateRepository : ISalesEvidenceLACoordinateRepository
+    {
+        private readonly AppDbContext _context;
+
+        public SalesEvidenceLACoordinateRepository(AppDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<SalesEvidenceLACoordinate>> GetAllAsync()
+        {
+            return await _context.SalesEvidenceLACoordinates
+                .Include(c => c.SalesEvidence)
+                .Include(c => c.Masterfile)
+                .ToListAsync();
+        }
+
+        public async Task<SalesEvidenceLACoordinate> GetByIdAsync(int id)
+        {
+            return await _context.SalesEvidenceLACoordinates
+                .Include(c => c.SalesEvidence)
+                .Include(c => c.Masterfile)
+                .FirstOrDefaultAsync(c => c.Id == id);
+        }
+
+        public async Task<IEnumerable<SalesEvidenceLACoordinate>> GetBySalesEvidenceIdAsync(int salesEvidenceId)
+        {
+            return await _context.SalesEvidenceLACoordinates
+                .Include(c => c.SalesEvidence)
+                .Include(c => c.Masterfile)
+                .Where(c => c.SalesEvidenceId == salesEvidenceId)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<SalesEvidenceLACoordinate>> GetByMasterfileIdAsync(int masterfileId)
+        {
+            return await _context.SalesEvidenceLACoordinates
+                .Include(c => c.SalesEvidence)
+                .Include(c => c.Masterfile)
+                .Where(c => c.MasterfileId == masterfileId)
+                .ToListAsync();
+        }
+
+        public async Task<SalesEvidenceLACoordinate> CreateAsync(SalesEvidenceLACoordinate coordinate)
+        {
+            coordinate.CreatedAt = DateTime.UtcNow;
+            _context.SalesEvidenceLACoordinates.Add(coordinate);
+            await _context.SaveChangesAsync();
+            
+            await _context.Entry(coordinate)
+                .Reference(c => c.SalesEvidence)
+                .LoadAsync();
+                
+            return coordinate;
+        }
+
+        public async Task<bool> UpdateAsync(SalesEvidenceLACoordinate coordinate)
+        {
+            try
+            {
+                coordinate.UpdatedAt = DateTime.UtcNow;
+                _context.Entry(coordinate).State = EntityState.Modified;
+                await _context.SaveChangesAsync();
+                return true;
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                return false;
+            }
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            var coordinate = await _context.SalesEvidenceLACoordinates.FindAsync(id);
+            if (coordinate == null)
+            {
+                return false;
+            }
+
+            _context.SalesEvidenceLACoordinates.Remove(coordinate);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        public async Task<bool> ExistsAsync(int id)
+        {
+            return await _context.SalesEvidenceLACoordinates.AnyAsync(c => c.Id == id);
+        }
+
+        public async Task<bool> SalesEvidenceExistsAsync(int salesEvidenceId)
+        {
+            return await _context.SalesEvidencesLA.AnyAsync(s => s.Id == salesEvidenceId);
+        }
+
+        public async Task<bool> MasterFileExistsAsync(int masterFileId)
+        {
+            return await _context.LandAquisitionMasterFiles.AnyAsync(m => m.Id == masterFileId);
+        }
+    }
+
+    // RentalEvidenceLA Coordinate Repository
+    public class RentalEvidenceLACoordinateRepository : IRentalEvidenceLACoordinateRepository
+    {
+        private readonly AppDbContext _context;
+
+        public RentalEvidenceLACoordinateRepository(AppDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<RentalEvidenceLACoordinate>> GetAllAsync()
+        {
+            return await _context.RentalEvidenceLACoordinates
+                .Include(c => c.RentalEvidence)
+                .Include(c => c.Masterfile)
+                .ToListAsync();
+        }
+
+        public async Task<RentalEvidenceLACoordinate> GetByIdAsync(int id)
+        {
+            return await _context.RentalEvidenceLACoordinates
+                .Include(c => c.RentalEvidence)
+                .Include(c => c.Masterfile)
+                .FirstOrDefaultAsync(c => c.Id == id);
+        }
+
+        public async Task<IEnumerable<RentalEvidenceLACoordinate>> GetByRentalEvidenceIdAsync(int rentalEvidenceId)
+        {
+            return await _context.RentalEvidenceLACoordinates
+                .Include(c => c.RentalEvidence)
+                .Include(c => c.Masterfile)
+                .Where(c => c.RentalEvidenceId == rentalEvidenceId)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<RentalEvidenceLACoordinate>> GetByMasterfileIdAsync(int masterfileId)
+        {
+            return await _context.RentalEvidenceLACoordinates
+                .Include(c => c.RentalEvidence)
+                .Include(c => c.Masterfile)
+                .Where(c => c.MasterfileId == masterfileId)
+                .ToListAsync();
+        }
+
+        public async Task<RentalEvidenceLACoordinate> CreateAsync(RentalEvidenceLACoordinate coordinate)
+        {
+            coordinate.CreatedAt = DateTime.UtcNow;
+            _context.RentalEvidenceLACoordinates.Add(coordinate);
+            await _context.SaveChangesAsync();
+            
+            await _context.Entry(coordinate)
+                .Reference(c => c.RentalEvidence)
+                .LoadAsync();
+                
+            return coordinate;
+        }
+
+        public async Task<bool> UpdateAsync(RentalEvidenceLACoordinate coordinate)
+        {
+            try
+            {
+                coordinate.UpdatedAt = DateTime.UtcNow;
+                _context.Entry(coordinate).State = EntityState.Modified;
+                await _context.SaveChangesAsync();
+                return true;
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                return false;
+            }
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            var coordinate = await _context.RentalEvidenceLACoordinates.FindAsync(id);
+            if (coordinate == null)
+            {
+                return false;
+            }
+
+            _context.RentalEvidenceLACoordinates.Remove(coordinate);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        public async Task<bool> ExistsAsync(int id)
+        {
+            return await _context.RentalEvidenceLACoordinates.AnyAsync(c => c.Id == id);
+        }
+
+        public async Task<bool> RentalEvidenceExistsAsync(int rentalEvidenceId)
+        {
+            return await _context.RentalEvidencesLA.AnyAsync(r => r.Id == rentalEvidenceId);
+        }
+
+        public async Task<bool> MasterFileExistsAsync(int masterFileId)
+        {
+            return await _context.LandAquisitionMasterFiles.AnyAsync(m => m.Id == masterFileId);
+        }
+    }
+}
diff --git a/repositories/LALotRepository.cs b/repositories/LALotRepository.cs
new file mode 100644
index 0000000..98fac63
--- /dev/null
+++ b/repositories/LALotRepository.cs
@@ -0,0 +1,93 @@
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using ValuationBackend.Data;
+using ValuationBackend.Models;
+
+namespace ValuationBackend.Repositories
+{
+    public class LALotRepository : ILALotRepository
+    {
+        private readonly AppDbContext _context;
+
+        public LALotRepository(AppDbContext context)
+        {
+            _context = context;
+        }
+
+        public async Task<IEnumerable<LALot>> GetAllAsync()
+        {
+            return await _context.LALots
+                .Include(l => l.MasterFile)
+                .ToListAsync();
+        }
+
+        public async Task<LALot> GetByIdAsync(int id)
+        {
+            return await _context.LALots
+                .Include(l => l.MasterFile)
+                .FirstOrDefaultAsync(l => l.Id == id);
+        }
+
+        public async Task<IEnumerable<LALot>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            return await _context.LALots
+                .Include(l => l.MasterFile)
+                .Where(l => l.MasterFileId == masterFileId)
+                .ToListAsync();
+        }
+
+        public async Task<LALot> CreateAsync(LALot laLot)
+        {
+            laLot.CreatedAt = DateTime.UtcNow;
+            _context.LALots.Add(laLot);
+            await _context.SaveChangesAsync();
+            
+            // Load the MasterFile for the response
+            await _context.Entry(laLot)
+                .Reference(l => l.MasterFile)
+                .LoadAsync();
+                
+            return laLot;
+        }
+
+        public async Task<bool> UpdateAsync(LALot laLot)
+        {
+            try
+            {
+                laLot.UpdatedAt = DateTime.UtcNow;
+                _context.Entry(laLot).State = EntityState.Modified;
+                await _context.SaveChangesAsync();
+                return true;
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                return false;
+            }
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            var laLot = await _context.LALots.FindAsync(id);
+            if (laLot == null)
+            {
+                return false;
+            }
+
+            _context.LALots.Remove(laLot);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        public async Task<bool> ExistsAsync(int id)
+        {
+            return await _context.LALots.AnyAsync(l => l.Id == id);
+        }
+
+        public async Task<bool> MasterFileExistsAsync(int masterFileId)
+        {
+            return await _context.LandAquisitionMasterFiles.AnyAsync(m => m.Id == masterFileId);
+        }
+    }
+}
diff --git a/repositories/LMBuildingRatesRepository.cs b/repositories/LMBuildingRatesRepository.cs
index 456ba59..d83321a 100644
--- a/repositories/LMBuildingRatesRepository.cs
+++ b/repositories/LMBuildingRatesRepository.cs
@@ -27,6 +27,21 @@ public async Task<LMBuildingRates> GetByIdAsync(int id)
             return await _context.LMBuildingRates.FindAsync(id);
         }
 
+        public async Task<LMBuildingRates> GetByIdWithMasterFileAsync(int id)
+        {
+            return await _context.LMBuildingRates
+                .Include(br => br.LandMiscellaneousMasterFile)
+                .FirstOrDefaultAsync(br => br.Id == id);
+        }
+
+        public async Task<IEnumerable<LMBuildingRates>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            return await _context.LMBuildingRates
+                .Where(br => br.LandMiscellaneousMasterFileId == masterFileId)
+                .Include(br => br.LandMiscellaneousMasterFile)
+                .ToListAsync();
+        }
+
         public async Task<LMBuildingRates> GetByReportIdAsync(int reportId)
         {
             return await _context.LMBuildingRates
diff --git a/repositories/LMPastValuationRepository.cs b/repositories/LMPastValuationRepository.cs
index 472e846..4c35e5e 100644
--- a/repositories/LMPastValuationRepository.cs
+++ b/repositories/LMPastValuationRepository.cs
@@ -27,6 +27,21 @@ public async Task<LMPastValuation> GetByIdAsync(int id)
             return await _context.LMPastValuations.FindAsync(id);
         }
 
+        public async Task<LMPastValuation> GetByIdWithMasterFileAsync(int id)
+        {
+            return await _context.LMPastValuations
+                .Include(pv => pv.LandMiscellaneousMasterFile)
+                .FirstOrDefaultAsync(pv => pv.Id == id);
+        }
+
+        public async Task<IEnumerable<LMPastValuation>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            return await _context.LMPastValuations
+                .Where(pv => pv.LandMiscellaneousMasterFileId == masterFileId)
+                .Include(pv => pv.LandMiscellaneousMasterFile)
+                .ToListAsync();
+        }
+
         public async Task<LMPastValuation> GetByReportIdAsync(int reportId)
         {
             return await _context.LMPastValuations
diff --git a/repositories/LMRentalEvidenceRepository.cs b/repositories/LMRentalEvidenceRepository.cs
index 5e97dba..e33c529 100644
--- a/repositories/LMRentalEvidenceRepository.cs
+++ b/repositories/LMRentalEvidenceRepository.cs
@@ -33,6 +33,36 @@ public async Task<LMRentalEvidence> GetByReportIdAsync(int reportId)
                 .FirstOrDefaultAsync(re => re.ReportId == reportId);
         }
 
+        // NEW: Methods for foreign key relationship
+        public async Task<IEnumerable<LMRentalEvidence>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            return await _context.LMRentalEvidences
+                .Include(e => e.LandMiscellaneousMasterFile)
+                .Where(e => e.LandMiscellaneousMasterFileId == masterFileId)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<LMRentalEvidence>> GetByMasterFileRefNoAsync(string masterFileRefNo)
+        {
+            return await _context.LMRentalEvidences
+                .Include(e => e.LandMiscellaneousMasterFile)
+                .Where(e => e.MasterFileRefNo == masterFileRefNo)
+                .ToListAsync();
+        }
+
+        public async Task<IEnumerable<LMRentalEvidence>> GetAllWithMasterFileDataAsync()
+        {
+            return await _context.LMRentalEvidences
+                .Include(e => e.LandMiscellaneousMasterFile)
+                .ToListAsync();
+        }
+
+        public async Task<LandMiscellaneousMasterFile?> GetMasterFileByRefNoAsync(string refNo)
+        {
+            return await _context.LandMiscellaneousMasterFiles
+                .FirstOrDefaultAsync(m => m.MasterFileRefNo == refNo);
+        }
+
         public async Task<Report> CreateReportAsync(Report report)
         {
             report.Timestamp = DateTime.UtcNow;
diff --git a/repositories/LMSalesEvidenceRepository.cs b/repositories/LMSalesEvidenceRepository.cs
index 285a1a8..a51b62d 100644
--- a/repositories/LMSalesEvidenceRepository.cs
+++ b/repositories/LMSalesEvidenceRepository.cs
@@ -27,6 +27,21 @@ public async Task<LMSalesEvidence> GetByIdAsync(int id)
             return await _context.LMSalesEvidences.FindAsync(id);
         }
 
+        public async Task<LMSalesEvidence> GetByIdWithMasterFileAsync(int id)
+        {
+            return await _context.LMSalesEvidences
+                .Include(se => se.LandMiscellaneousMasterFile)
+                .FirstOrDefaultAsync(se => se.Id == id);
+        }
+
+        public async Task<IEnumerable<LMSalesEvidence>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            return await _context.LMSalesEvidences
+                .Where(se => se.LandMiscellaneousMasterFileId == masterFileId)
+                .Include(se => se.LandMiscellaneousMasterFile)
+                .ToListAsync();
+        }
+
         public async Task<LMSalesEvidence> GetByReportIdAsync(int reportId)
         {
             return await _context.LMSalesEvidences
diff --git a/repositories/LandMiscellaneousRepository.cs b/repositories/LandMiscellaneousRepository.cs
index ffda89b..f199b06 100644
--- a/repositories/LandMiscellaneousRepository.cs
+++ b/repositories/LandMiscellaneousRepository.cs
@@ -150,5 +150,12 @@ public async Task<int> GetSearchCountAsync(string searchTerm, int? assignedToUse
 
             return await query.CountAsync();
         }
+
+        // NEW: Method for foreign key support
+        public async Task<LandMiscellaneousMasterFile?> GetByRefNoAsync(string refNo)
+        {
+            return await _context.LandMiscellaneousMasterFiles
+                .FirstOrDefaultAsync(m => m.MasterFileRefNo == refNo);
+        }
     }
 }
diff --git a/services/AssetNumberChangeService.cs b/services/AssetNumberChangeService.cs
index 8fe6079..4e5431e 100644
--- a/services/AssetNumberChangeService.cs
+++ b/services/AssetNumberChangeService.cs
@@ -37,7 +37,7 @@ public async Task<IEnumerable<AssetNumberChange>> GetByNewAssetNoAsync(string ne
 
         public async Task<AssetNumberChange> CreateAssetNumberChangeAsync(AssetNumberChange assetNumberChange)
         {
-            // Set default values if not provided
+            // Set default values if not provided 
             assetNumberChange.DateOfChange = DateTime.UtcNow;
             if (assetNumberChange.ChangedDate == null)
             {
diff --git a/services/DecisionFieldService.cs b/services/DecisionFieldService.cs
new file mode 100644
index 0000000..1d705f9
--- /dev/null
+++ b/services/DecisionFieldService.cs
@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models;
+using ValuationBackend.Repositories;
+
+namespace ValuationBackend.Services
+{
+    public class DecisionFieldService
+    {
+        private readonly DecisionFieldRepository _repository;
+
+        public DecisionFieldService(DecisionFieldRepository repository)
+        {
+            _repository = repository;
+        }
+
+        public async Task<IEnumerable<DecisionField>> GetAllFieldsAsync()
+        {
+            return await _repository.GetAllAsync();
+        }
+
+        public async Task<DecisionField> CreateFieldAsync(DecisionField field)
+        {
+            return await _repository.AddAsync(field);
+        }
+
+        // Add more methods as needed for business logic
+    }
+}
diff --git a/services/EmailSender.cs b/services/EmailSender.cs
new file mode 100644
index 0000000..3a5326d
--- /dev/null
+++ b/services/EmailSender.cs
@@ -0,0 +1,35 @@
+using System.Net;
+using System.Net.Mail;
+using System.Threading.Tasks;
+using System;
+
+namespace ValuationBackend.Services
+{
+    public class EmailSender : IEmailSender
+    {
+        public async Task SendAsync(string to, string subject, string body)
+        {
+            // Read from environment variables (set in .env or your deployment environment)
+            var gmailAddress = Environment.GetEnvironmentVariable("GMAIL_ADDRESS");
+            var gmailAppPassword = Environment.GetEnvironmentVariable("GMAIL_APP_PASSWORD");
+
+            var smtpClient = new SmtpClient("smtp.gmail.com")
+            {
+                Port = 587,
+                Credentials = new NetworkCredential(gmailAddress, gmailAppPassword),
+                EnableSsl = true,
+            };
+
+            var mailMessage = new MailMessage
+            {
+                From = new MailAddress(gmailAddress, "Valuation Department"),
+                Subject = subject,
+                Body = body,
+                IsBodyHtml = true, // Enable HTML
+            };
+            mailMessage.To.Add(to);
+
+            await smtpClient.SendMailAsync(mailMessage);
+        }
+    }
+} 
\ No newline at end of file
diff --git a/services/IEmailSender.cs b/services/IEmailSender.cs
new file mode 100644
index 0000000..640cc53
--- /dev/null
+++ b/services/IEmailSender.cs
@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace ValuationBackend.Services
+{
+    public interface IEmailSender
+    {
+        Task SendAsync(string to, string subject, string body);
+    }
+} 
\ No newline at end of file
diff --git a/services/ILACoordinateServices.cs b/services/ILACoordinateServices.cs
new file mode 100644
index 0000000..f0b31a5
--- /dev/null
+++ b/services/ILACoordinateServices.cs
@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models.DTOs;
+
+namespace ValuationBackend.Services
+{
+    // PastValuationsLA Coordinate Service
+    public interface IPastValuationsLACoordinateService
+    {
+        Task<IEnumerable<PastValuationsLACoordinateResponseDto>> GetAllAsync();
+        Task<PastValuationsLACoordinateResponseDto> GetByIdAsync(int id);
+        Task<IEnumerable<PastValuationsLACoordinateResponseDto>> GetByPastValuationIdAsync(int pastValuationId);
+        Task<IEnumerable<PastValuationsLACoordinateResponseDto>> GetByMasterfileIdAsync(int masterfileId);
+        Task<PastValuationsLACoordinateResponseDto> CreateAsync(PastValuationsLACoordinateCreateDto dto);
+        Task<PastValuationsLACoordinateResponseDto> UpdateAsync(int id, PastValuationsLACoordinateUpdateDto dto);
+        Task<bool> DeleteAsync(int id);
+    }
+
+    // BuildingRatesLA Coordinate Service
+    public interface IBuildingRatesLACoordinateService
+    {
+        Task<IEnumerable<BuildingRatesLACoordinateResponseDto>> GetAllAsync();
+        Task<BuildingRatesLACoordinateResponseDto> GetByIdAsync(int id);
+        Task<IEnumerable<BuildingRatesLACoordinateResponseDto>> GetByBuildingRateIdAsync(int buildingRateId);
+        Task<IEnumerable<BuildingRatesLACoordinateResponseDto>> GetByMasterfileIdAsync(int masterfileId);
+        Task<BuildingRatesLACoordinateResponseDto> CreateAsync(BuildingRatesLACoordinateCreateDto dto);
+        Task<BuildingRatesLACoordinateResponseDto> UpdateAsync(int id, BuildingRatesLACoordinateUpdateDto dto);
+        Task<bool> DeleteAsync(int id);
+    }
+
+    // SalesEvidenceLA Coordinate Service
+    public interface ISalesEvidenceLACoordinateService
+    {
+        Task<IEnumerable<SalesEvidenceLACoordinateResponseDto>> GetAllAsync();
+        Task<SalesEvidenceLACoordinateResponseDto> GetByIdAsync(int id);
+        Task<IEnumerable<SalesEvidenceLACoordinateResponseDto>> GetBySalesEvidenceIdAsync(int salesEvidenceId);
+        Task<IEnumerable<SalesEvidenceLACoordinateResponseDto>> GetByMasterfileIdAsync(int masterfileId);
+        Task<SalesEvidenceLACoordinateResponseDto> CreateAsync(SalesEvidenceLACoordinateCreateDto dto);
+        Task<SalesEvidenceLACoordinateResponseDto> UpdateAsync(int id, SalesEvidenceLACoordinateUpdateDto dto);
+        Task<bool> DeleteAsync(int id);
+    }
+
+    // RentalEvidenceLA Coordinate Service
+    public interface IRentalEvidenceLACoordinateService
+    {
+        Task<IEnumerable<RentalEvidenceLACoordinateResponseDto>> GetAllAsync();
+        Task<RentalEvidenceLACoordinateResponseDto> GetByIdAsync(int id);
+        Task<IEnumerable<RentalEvidenceLACoordinateResponseDto>> GetByRentalEvidenceIdAsync(int rentalEvidenceId);
+        Task<IEnumerable<RentalEvidenceLACoordinateResponseDto>> GetByMasterfileIdAsync(int masterfileId);
+        Task<RentalEvidenceLACoordinateResponseDto> CreateAsync(RentalEvidenceLACoordinateCreateDto dto);
+        Task<RentalEvidenceLACoordinateResponseDto> UpdateAsync(int id, RentalEvidenceLACoordinateUpdateDto dto);
+        Task<bool> DeleteAsync(int id);
+    }
+}
diff --git a/services/ILALotService.cs b/services/ILALotService.cs
new file mode 100644
index 0000000..4201f0a
--- /dev/null
+++ b/services/ILALotService.cs
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models.DTOs;
+
+namespace ValuationBackend.Services
+{
+    public interface ILALotService
+    {
+        Task<IEnumerable<LALotResponseDto>> GetAllAsync();
+        Task<LALotResponseDto> GetByIdAsync(int id);
+        Task<IEnumerable<LALotResponseDto>> GetByMasterFileIdAsync(int masterFileId);
+        Task<LALotResponseDto> CreateAsync(LALotCreateDto dto);
+        Task<LALotResponseDto> UpdateAsync(int id, LALotUpdateDto dto);
+        Task<bool> DeleteAsync(int id);
+    }
+}
diff --git a/services/ILMBuildingRatesService.cs b/services/ILMBuildingRatesService.cs
index 0f187e5..dfafab5 100644
--- a/services/ILMBuildingRatesService.cs
+++ b/services/ILMBuildingRatesService.cs
@@ -8,6 +8,7 @@ public interface ILMBuildingRatesService
     {
         Task<IEnumerable<LMBuildingRatesResponseDto>> GetAllAsync();
         Task<LMBuildingRatesResponseDto> GetByIdAsync(int id);
+        Task<IEnumerable<LMBuildingRatesResponseDto>> GetByMasterFileIdAsync(int masterFileId);
         Task<LMBuildingRatesResponseDto> GetByReportIdAsync(int reportId);
         Task<LMBuildingRatesResponseDto> CreateAsync(LMBuildingRatesCreateDto dto);
         Task<bool> UpdateAsync(int reportId, LMBuildingRatesUpdateDto dto);
diff --git a/services/ILMPastValuationService.cs b/services/ILMPastValuationService.cs
index 048563e..b3b22b5 100644
--- a/services/ILMPastValuationService.cs
+++ b/services/ILMPastValuationService.cs
@@ -8,6 +8,7 @@ public interface ILMPastValuationService
     {
         Task<IEnumerable<LMPastValuationResponseDto>> GetAllAsync();
         Task<LMPastValuationResponseDto> GetByIdAsync(int id);
+        Task<IEnumerable<LMPastValuationResponseDto>> GetByMasterFileIdAsync(int masterFileId);
         Task<LMPastValuationResponseDto> GetByReportIdAsync(int reportId);
         Task<LMPastValuationResponseDto> CreateAsync(LMPastValuationCreateDto dto);
         Task<bool> UpdateAsync(int reportId, LMPastValuationUpdateDto dto);
diff --git a/services/ILMRentalEvidenceService.cs b/services/ILMRentalEvidenceService.cs
index 480fb4e..c83a7da 100644
--- a/services/ILMRentalEvidenceService.cs
+++ b/services/ILMRentalEvidenceService.cs
@@ -7,8 +7,14 @@ namespace ValuationBackend.Services
     public interface ILMRentalEvidenceService
     {
         Task<IEnumerable<LMRentalEvidenceResponseDto>> GetAllAsync();
-        Task<LMRentalEvidenceResponseDto> GetByIdAsync(int id);
-        Task<LMRentalEvidenceResponseDto> GetByReportIdAsync(int reportId);
+        Task<LMRentalEvidenceResponseDto?> GetByIdAsync(int id);
+        Task<LMRentalEvidenceResponseDto?> GetByReportIdAsync(int reportId);
+
+        // NEW: Methods for foreign key relationship
+        Task<IEnumerable<LMRentalEvidenceResponseDto>> GetByMasterFileIdAsync(int masterFileId);
+        Task<IEnumerable<LMRentalEvidenceResponseDto>> GetByMasterFileRefNoAsync(string masterFileRefNo);
+        Task<IEnumerable<LMRentalEvidenceResponseDto>> GetAllWithMasterFileDataAsync();
+
         Task<LMRentalEvidenceResponseDto> CreateAsync(LMRentalEvidenceCreateDto dto);
         Task<bool> UpdateAsync(int reportId, LMRentalEvidenceUpdateDto dto);
         Task<bool> DeleteAsync(int id);
diff --git a/services/ILMSalesEvidenceService.cs b/services/ILMSalesEvidenceService.cs
index 28b9624..60dae47 100644
--- a/services/ILMSalesEvidenceService.cs
+++ b/services/ILMSalesEvidenceService.cs
@@ -8,6 +8,7 @@ public interface ILMSalesEvidenceService
     {
         Task<IEnumerable<LMSalesEvidenceResponseDto>> GetAllAsync();
         Task<LMSalesEvidenceResponseDto> GetByIdAsync(int id);
+        Task<IEnumerable<LMSalesEvidenceResponseDto>> GetByMasterFileIdAsync(int masterFileId);
         Task<LMSalesEvidenceResponseDto> GetByReportIdAsync(int reportId);
         Task<LMSalesEvidenceResponseDto> CreateAsync(LMSalesEvidenceCreateDto dto);
         Task<bool> UpdateAsync(int reportId, LMSalesEvidenceUpdateDto dto);
diff --git a/services/LACoordinateServices.cs b/services/LACoordinateServices.cs
new file mode 100644
index 0000000..becfd4d
--- /dev/null
+++ b/services/LACoordinateServices.cs
@@ -0,0 +1,385 @@
+using AutoMapper;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models;
+using ValuationBackend.Models.DTOs;
+using ValuationBackend.Repositories;
+
+namespace ValuationBackend.Services
+{
+    // PastValuationsLA Coordinate Service
+    public class PastValuationsLACoordinateService : IPastValuationsLACoordinateService
+    {
+        private readonly IPastValuationsLACoordinateRepository _repository;
+        private readonly IMapper _mapper;
+
+        public PastValuationsLACoordinateService(IPastValuationsLACoordinateRepository repository, IMapper mapper)
+        {
+            _repository = repository;
+            _mapper = mapper;
+        }
+
+        public async Task<IEnumerable<PastValuationsLACoordinateResponseDto>> GetAllAsync()
+        {
+            var coordinates = await _repository.GetAllAsync();
+            return _mapper.Map<IEnumerable<PastValuationsLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<PastValuationsLACoordinateResponseDto> GetByIdAsync(int id)
+        {
+            var coordinate = await _repository.GetByIdAsync(id);
+            if (coordinate == null)
+            {
+                return null;
+            }
+
+            return _mapper.Map<PastValuationsLACoordinateResponseDto>(coordinate);
+        }
+
+        public async Task<IEnumerable<PastValuationsLACoordinateResponseDto>> GetByPastValuationIdAsync(int pastValuationId)
+        {
+            var coordinates = await _repository.GetByPastValuationIdAsync(pastValuationId);
+            return _mapper.Map<IEnumerable<PastValuationsLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<IEnumerable<PastValuationsLACoordinateResponseDto>> GetByMasterfileIdAsync(int masterfileId)
+        {
+            var coordinates = await _repository.GetByMasterfileIdAsync(masterfileId);
+            return _mapper.Map<IEnumerable<PastValuationsLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<PastValuationsLACoordinateResponseDto> CreateAsync(PastValuationsLACoordinateCreateDto dto)
+        {
+            var masterFileExists = await _repository.MasterFileExistsAsync(dto.MasterfileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"Masterfile with ID {dto.MasterfileId} does not exist.");
+            }
+
+            var coordinate = _mapper.Map<PastValuationsLACoordinate>(dto);
+            // Set PastValuationId to null since it will be assigned later
+            coordinate.PastValuationId = null;
+            var createdCoordinate = await _repository.CreateAsync(coordinate);
+            return _mapper.Map<PastValuationsLACoordinateResponseDto>(createdCoordinate);
+        }
+
+        public async Task<PastValuationsLACoordinateResponseDto> UpdateAsync(int id, PastValuationsLACoordinateUpdateDto dto)
+        {
+            var existingCoordinate = await _repository.GetByIdAsync(id);
+            if (existingCoordinate == null)
+            {
+                return null;
+            }
+
+            var pastValuationExists = await _repository.PastValuationExistsAsync(dto.PastValuationId);
+            if (!pastValuationExists)
+            {
+                throw new ArgumentException($"PastValuation with ID {dto.PastValuationId} does not exist.");
+            }
+
+            var masterFileExists = await _repository.MasterFileExistsAsync(dto.MasterfileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"Masterfile with ID {dto.MasterfileId} does not exist.");
+            }
+
+            _mapper.Map(dto, existingCoordinate);
+            
+            var updateSuccess = await _repository.UpdateAsync(existingCoordinate);
+            if (!updateSuccess)
+            {
+                throw new InvalidOperationException("Failed to update coordinate.");
+            }
+
+            var updatedCoordinate = await _repository.GetByIdAsync(id);
+            return _mapper.Map<PastValuationsLACoordinateResponseDto>(updatedCoordinate);
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            return await _repository.DeleteAsync(id);
+        }
+    }
+
+    // BuildingRatesLA Coordinate Service
+    public class BuildingRatesLACoordinateService : IBuildingRatesLACoordinateService
+    {
+        private readonly IBuildingRatesLACoordinateRepository _repository;
+        private readonly IMapper _mapper;
+
+        public BuildingRatesLACoordinateService(IBuildingRatesLACoordinateRepository repository, IMapper mapper)
+        {
+            _repository = repository;
+            _mapper = mapper;
+        }
+
+        public async Task<IEnumerable<BuildingRatesLACoordinateResponseDto>> GetAllAsync()
+        {
+            var coordinates = await _repository.GetAllAsync();
+            return _mapper.Map<IEnumerable<BuildingRatesLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<BuildingRatesLACoordinateResponseDto> GetByIdAsync(int id)
+        {
+            var coordinate = await _repository.GetByIdAsync(id);
+            if (coordinate == null)
+            {
+                return null;
+            }
+
+            return _mapper.Map<BuildingRatesLACoordinateResponseDto>(coordinate);
+        }
+
+        public async Task<IEnumerable<BuildingRatesLACoordinateResponseDto>> GetByBuildingRateIdAsync(int buildingRateId)
+        {
+            var coordinates = await _repository.GetByBuildingRateIdAsync(buildingRateId);
+            return _mapper.Map<IEnumerable<BuildingRatesLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<IEnumerable<BuildingRatesLACoordinateResponseDto>> GetByMasterfileIdAsync(int masterfileId)
+        {
+            var coordinates = await _repository.GetByMasterfileIdAsync(masterfileId);
+            return _mapper.Map<IEnumerable<BuildingRatesLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<BuildingRatesLACoordinateResponseDto> CreateAsync(BuildingRatesLACoordinateCreateDto dto)
+        {
+            var masterFileExists = await _repository.MasterFileExistsAsync(dto.MasterfileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"Masterfile with ID {dto.MasterfileId} does not exist.");
+            }
+
+            var coordinate = _mapper.Map<BuildingRatesLACoordinate>(dto);
+            // Set BuildingRateId to null since it will be assigned later
+            coordinate.BuildingRateId = null;
+            var createdCoordinate = await _repository.CreateAsync(coordinate);
+            return _mapper.Map<BuildingRatesLACoordinateResponseDto>(createdCoordinate);
+        }
+
+        public async Task<BuildingRatesLACoordinateResponseDto> UpdateAsync(int id, BuildingRatesLACoordinateUpdateDto dto)
+        {
+            var existingCoordinate = await _repository.GetByIdAsync(id);
+            if (existingCoordinate == null)
+            {
+                return null;
+            }
+
+            var buildingRateExists = await _repository.BuildingRateExistsAsync(dto.BuildingRateId);
+            if (!buildingRateExists)
+            {
+                throw new ArgumentException($"BuildingRate with ID {dto.BuildingRateId} does not exist.");
+            }
+
+            var masterFileExists = await _repository.MasterFileExistsAsync(dto.MasterfileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"Masterfile with ID {dto.MasterfileId} does not exist.");
+            }
+
+            _mapper.Map(dto, existingCoordinate);
+            
+            var updateSuccess = await _repository.UpdateAsync(existingCoordinate);
+            if (!updateSuccess)
+            {
+                throw new InvalidOperationException("Failed to update coordinate.");
+            }
+
+            var updatedCoordinate = await _repository.GetByIdAsync(id);
+            return _mapper.Map<BuildingRatesLACoordinateResponseDto>(updatedCoordinate);
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            return await _repository.DeleteAsync(id);
+        }
+    }
+
+    // SalesEvidenceLA Coordinate Service
+    public class SalesEvidenceLACoordinateService : ISalesEvidenceLACoordinateService
+    {
+        private readonly ISalesEvidenceLACoordinateRepository _repository;
+        private readonly IMapper _mapper;
+
+        public SalesEvidenceLACoordinateService(ISalesEvidenceLACoordinateRepository repository, IMapper mapper)
+        {
+            _repository = repository;
+            _mapper = mapper;
+        }
+
+        public async Task<IEnumerable<SalesEvidenceLACoordinateResponseDto>> GetAllAsync()
+        {
+            var coordinates = await _repository.GetAllAsync();
+            return _mapper.Map<IEnumerable<SalesEvidenceLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<SalesEvidenceLACoordinateResponseDto> GetByIdAsync(int id)
+        {
+            var coordinate = await _repository.GetByIdAsync(id);
+            if (coordinate == null)
+            {
+                return null;
+            }
+
+            return _mapper.Map<SalesEvidenceLACoordinateResponseDto>(coordinate);
+        }
+
+        public async Task<IEnumerable<SalesEvidenceLACoordinateResponseDto>> GetBySalesEvidenceIdAsync(int salesEvidenceId)
+        {
+            var coordinates = await _repository.GetBySalesEvidenceIdAsync(salesEvidenceId);
+            return _mapper.Map<IEnumerable<SalesEvidenceLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<IEnumerable<SalesEvidenceLACoordinateResponseDto>> GetByMasterfileIdAsync(int masterfileId)
+        {
+            var coordinates = await _repository.GetByMasterfileIdAsync(masterfileId);
+            return _mapper.Map<IEnumerable<SalesEvidenceLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<SalesEvidenceLACoordinateResponseDto> CreateAsync(SalesEvidenceLACoordinateCreateDto dto)
+        {
+            var masterFileExists = await _repository.MasterFileExistsAsync(dto.MasterfileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"Masterfile with ID {dto.MasterfileId} does not exist.");
+            }
+
+            var coordinate = _mapper.Map<SalesEvidenceLACoordinate>(dto);
+            // Set SalesEvidenceId to null since it will be assigned later
+            coordinate.SalesEvidenceId = null;
+            var createdCoordinate = await _repository.CreateAsync(coordinate);
+            return _mapper.Map<SalesEvidenceLACoordinateResponseDto>(createdCoordinate);
+        }
+
+        public async Task<SalesEvidenceLACoordinateResponseDto> UpdateAsync(int id, SalesEvidenceLACoordinateUpdateDto dto)
+        {
+            var existingCoordinate = await _repository.GetByIdAsync(id);
+            if (existingCoordinate == null)
+            {
+                return null;
+            }
+
+            var salesEvidenceExists = await _repository.SalesEvidenceExistsAsync(dto.SalesEvidenceId);
+            if (!salesEvidenceExists)
+            {
+                throw new ArgumentException($"SalesEvidence with ID {dto.SalesEvidenceId} does not exist.");
+            }
+
+            var masterFileExists = await _repository.MasterFileExistsAsync(dto.MasterfileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"Masterfile with ID {dto.MasterfileId} does not exist.");
+            }
+
+            _mapper.Map(dto, existingCoordinate);
+            
+            var updateSuccess = await _repository.UpdateAsync(existingCoordinate);
+            if (!updateSuccess)
+            {
+                throw new InvalidOperationException("Failed to update coordinate.");
+            }
+
+            var updatedCoordinate = await _repository.GetByIdAsync(id);
+            return _mapper.Map<SalesEvidenceLACoordinateResponseDto>(updatedCoordinate);
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            return await _repository.DeleteAsync(id);
+        }
+    }
+
+    // RentalEvidenceLA Coordinate Service
+    public class RentalEvidenceLACoordinateService : IRentalEvidenceLACoordinateService
+    {
+        private readonly IRentalEvidenceLACoordinateRepository _repository;
+        private readonly IMapper _mapper;
+
+        public RentalEvidenceLACoordinateService(IRentalEvidenceLACoordinateRepository repository, IMapper mapper)
+        {
+            _repository = repository;
+            _mapper = mapper;
+        }
+
+        public async Task<IEnumerable<RentalEvidenceLACoordinateResponseDto>> GetAllAsync()
+        {
+            var coordinates = await _repository.GetAllAsync();
+            return _mapper.Map<IEnumerable<RentalEvidenceLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<RentalEvidenceLACoordinateResponseDto> GetByIdAsync(int id)
+        {
+            var coordinate = await _repository.GetByIdAsync(id);
+            if (coordinate == null)
+            {
+                return null;
+            }
+
+            return _mapper.Map<RentalEvidenceLACoordinateResponseDto>(coordinate);
+        }
+
+        public async Task<IEnumerable<RentalEvidenceLACoordinateResponseDto>> GetByRentalEvidenceIdAsync(int rentalEvidenceId)
+        {
+            var coordinates = await _repository.GetByRentalEvidenceIdAsync(rentalEvidenceId);
+            return _mapper.Map<IEnumerable<RentalEvidenceLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<IEnumerable<RentalEvidenceLACoordinateResponseDto>> GetByMasterfileIdAsync(int masterfileId)
+        {
+            var coordinates = await _repository.GetByMasterfileIdAsync(masterfileId);
+            return _mapper.Map<IEnumerable<RentalEvidenceLACoordinateResponseDto>>(coordinates);
+        }
+
+        public async Task<RentalEvidenceLACoordinateResponseDto> CreateAsync(RentalEvidenceLACoordinateCreateDto dto)
+        {
+            var masterFileExists = await _repository.MasterFileExistsAsync(dto.MasterfileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"Masterfile with ID {dto.MasterfileId} does not exist.");
+            }
+
+            var coordinate = _mapper.Map<RentalEvidenceLACoordinate>(dto);
+            // Set RentalEvidenceId to null since it will be assigned later
+            coordinate.RentalEvidenceId = null;
+            var createdCoordinate = await _repository.CreateAsync(coordinate);
+            return _mapper.Map<RentalEvidenceLACoordinateResponseDto>(createdCoordinate);
+        }
+
+        public async Task<RentalEvidenceLACoordinateResponseDto> UpdateAsync(int id, RentalEvidenceLACoordinateUpdateDto dto)
+        {
+            var existingCoordinate = await _repository.GetByIdAsync(id);
+            if (existingCoordinate == null)
+            {
+                return null;
+            }
+
+            var rentalEvidenceExists = await _repository.RentalEvidenceExistsAsync(dto.RentalEvidenceId);
+            if (!rentalEvidenceExists)
+            {
+                throw new ArgumentException($"RentalEvidence with ID {dto.RentalEvidenceId} does not exist.");
+            }
+
+            var masterFileExists = await _repository.MasterFileExistsAsync(dto.MasterfileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"Masterfile with ID {dto.MasterfileId} does not exist.");
+            }
+
+            _mapper.Map(dto, existingCoordinate);
+            
+            var updateSuccess = await _repository.UpdateAsync(existingCoordinate);
+            if (!updateSuccess)
+            {
+                throw new InvalidOperationException("Failed to update coordinate.");
+            }
+
+            var updatedCoordinate = await _repository.GetByIdAsync(id);
+            return _mapper.Map<RentalEvidenceLACoordinateResponseDto>(updatedCoordinate);
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            return await _repository.DeleteAsync(id);
+        }
+    }
+}
diff --git a/services/LALotService.cs b/services/LALotService.cs
new file mode 100644
index 0000000..a9976a7
--- /dev/null
+++ b/services/LALotService.cs
@@ -0,0 +1,90 @@
+using AutoMapper;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using ValuationBackend.Models;
+using ValuationBackend.Models.DTOs;
+using ValuationBackend.Repositories;
+
+namespace ValuationBackend.Services
+{
+    public class LALotService : ILALotService
+    {
+        private readonly ILALotRepository _laLotRepository;
+        private readonly IMapper _mapper;
+
+        public LALotService(ILALotRepository laLotRepository, IMapper mapper)
+        {
+            _laLotRepository = laLotRepository;
+            _mapper = mapper;
+        }
+
+        public async Task<IEnumerable<LALotResponseDto>> GetAllAsync()
+        {
+            var laLots = await _laLotRepository.GetAllAsync();
+            return _mapper.Map<IEnumerable<LALotResponseDto>>(laLots);
+        }
+
+        public async Task<LALotResponseDto> GetByIdAsync(int id)
+        {
+            var laLot = await _laLotRepository.GetByIdAsync(id);
+            if (laLot == null)
+            {
+                return null;
+            }
+
+            return _mapper.Map<LALotResponseDto>(laLot);
+        }
+
+        public async Task<IEnumerable<LALotResponseDto>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            var laLots = await _laLotRepository.GetByMasterFileIdAsync(masterFileId);
+            return _mapper.Map<IEnumerable<LALotResponseDto>>(laLots);
+        }
+
+        public async Task<LALotResponseDto> CreateAsync(LALotCreateDto dto)
+        {
+            // Validate that the MasterFile exists
+            var masterFileExists = await _laLotRepository.MasterFileExistsAsync(dto.MasterFileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"MasterFile with ID {dto.MasterFileId} does not exist.");
+            }
+
+            var laLot = _mapper.Map<LALot>(dto);
+            var createdLaLot = await _laLotRepository.CreateAsync(laLot);
+            return _mapper.Map<LALotResponseDto>(createdLaLot);
+        }
+
+        public async Task<LALotResponseDto> UpdateAsync(int id, LALotUpdateDto dto)
+        {
+            var existingLaLot = await _laLotRepository.GetByIdAsync(id);
+            if (existingLaLot == null)
+            {
+                return null;
+            }
+
+            // Validate that the MasterFile exists
+            var masterFileExists = await _laLotRepository.MasterFileExistsAsync(dto.MasterFileId);
+            if (!masterFileExists)
+            {
+                throw new ArgumentException($"MasterFile with ID {dto.MasterFileId} does not exist.");
+            }
+
+            _mapper.Map(dto, existingLaLot);
+            
+            var updateSuccess = await _laLotRepository.UpdateAsync(existingLaLot);
+            if (!updateSuccess)
+            {
+                throw new InvalidOperationException("Failed to update LALot.");
+            }
+
+            var updatedLaLot = await _laLotRepository.GetByIdAsync(id);
+            return _mapper.Map<LALotResponseDto>(updatedLaLot);
+        }
+
+        public async Task<bool> DeleteAsync(int id)
+        {
+            return await _laLotRepository.DeleteAsync(id);
+        }
+    }
+}
diff --git a/services/LMBuildingRatesService.cs b/services/LMBuildingRatesService.cs
index e0fd878..bf017c6 100644
--- a/services/LMBuildingRatesService.cs
+++ b/services/LMBuildingRatesService.cs
@@ -25,10 +25,16 @@ public async Task<IEnumerable<LMBuildingRatesResponseDto>> GetAllAsync()
 
         public async Task<LMBuildingRatesResponseDto> GetByIdAsync(int id)
         {
-            var lmBuildingRate = await _repository.GetByIdAsync(id);
+            var lmBuildingRate = await _repository.GetByIdWithMasterFileAsync(id);
             return lmBuildingRate == null ? null : MapToResponseDto(lmBuildingRate);
         }
 
+        public async Task<IEnumerable<LMBuildingRatesResponseDto>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            var lmBuildingRates = await _repository.GetByMasterFileIdAsync(masterFileId);
+            return lmBuildingRates.Select(MapToResponseDto).ToList();
+        }
+
         public async Task<LMBuildingRatesResponseDto> GetByReportIdAsync(int reportId)
         {
             var lmBuildingRate = await _repository.GetByReportIdAsync(reportId);
@@ -63,7 +69,8 @@ public async Task<LMBuildingRatesResponseDto> CreateAsync(LMBuildingRatesCreateD
                 Cost = dto.Cost,
                 Remarks = dto.Remarks,
                 LocationLatitude = dto.LocationLatitude,
-                LocationLongitude = dto.LocationLongitude
+                LocationLongitude = dto.LocationLongitude,
+                LandMiscellaneousMasterFileId = dto.LandMiscellaneousMasterFileId
             };
 
             lmBuildingRate = await _repository.CreateAsync(lmBuildingRate);
@@ -93,6 +100,7 @@ public async Task<bool> UpdateAsync(int reportId, LMBuildingRatesUpdateDto dto)
             existingLMBuildingRate.Remarks = dto.Remarks;
             existingLMBuildingRate.LocationLatitude = dto.LocationLatitude;
             existingLMBuildingRate.LocationLongitude = dto.LocationLongitude;
+            existingLMBuildingRate.LandMiscellaneousMasterFileId = dto.LandMiscellaneousMasterFileId;
 
             return await _repository.UpdateAsync(existingLMBuildingRate);
         }
@@ -119,7 +127,26 @@ private LMBuildingRatesResponseDto MapToResponseDto(LMBuildingRates lmBuildingRa
                 Cost = lmBuildingRate.Cost,
                 Remarks = lmBuildingRate.Remarks,
                 LocationLatitude = lmBuildingRate.LocationLatitude,
-                LocationLongitude = lmBuildingRate.LocationLongitude
+                LocationLongitude = lmBuildingRate.LocationLongitude,
+                LandMiscellaneousMasterFileId = lmBuildingRate.LandMiscellaneousMasterFileId,
+                LandMiscellaneousMasterFile = lmBuildingRate.LandMiscellaneousMasterFile != null
+                    ? MapMasterFileToDto(lmBuildingRate.LandMiscellaneousMasterFile)
+                    : null
+            };
+        }
+
+        private LandMiscellaneousMasterFileDto MapMasterFileToDto(LandMiscellaneousMasterFile masterFile)
+        {
+            return new LandMiscellaneousMasterFileDto
+            {
+                Id = masterFile.Id,
+                MasterFileNo = masterFile.MasterFileNo,
+                MasterFileRefNo = masterFile.MasterFileRefNo,
+                PlanType = masterFile.PlanType,
+                PlanNo = masterFile.PlanNo,
+                RequestingAuthorityReferenceNo = masterFile.RequestingAuthorityReferenceNo,
+                Status = masterFile.Status,
+                Lots = masterFile.Lots
             };
         }
     }
diff --git a/services/LMPastValuationService.cs b/services/LMPastValuationService.cs
index df43b9d..152c784 100644
--- a/services/LMPastValuationService.cs
+++ b/services/LMPastValuationService.cs
@@ -25,10 +25,16 @@ public async Task<IEnumerable<LMPastValuationResponseDto>> GetAllAsync()
 
         public async Task<LMPastValuationResponseDto> GetByIdAsync(int id)
         {
-            var lmPastValuation = await _repository.GetByIdAsync(id);
+            var lmPastValuation = await _repository.GetByIdWithMasterFileAsync(id);
             return lmPastValuation == null ? null : MapToResponseDto(lmPastValuation);
         }
 
+        public async Task<IEnumerable<LMPastValuationResponseDto>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            var lmPastValuations = await _repository.GetByMasterFileIdAsync(masterFileId);
+            return lmPastValuations.Select(MapToResponseDto).ToList();
+        }
+
         public async Task<LMPastValuationResponseDto> GetByReportIdAsync(int reportId)
         {
             var lmPastValuation = await _repository.GetByReportIdAsync(reportId);
@@ -63,7 +69,8 @@ public async Task<LMPastValuationResponseDto> CreateAsync(LMPastValuationCreateD
                 RateType = dto.RateType,
                 Remarks = dto.Remarks,
                 LocationLongitude = dto.LocationLongitude,
-                LocationLatitude = dto.LocationLatitude
+                LocationLatitude = dto.LocationLatitude,
+                LandMiscellaneousMasterFileId = dto.LandMiscellaneousMasterFileId
             };
 
             lmPastValuation = await _repository.CreateAsync(lmPastValuation);
@@ -93,6 +100,7 @@ public async Task<bool> UpdateAsync(int reportId, LMPastValuationUpdateDto dto)
             existingLMPastValuation.Remarks = dto.Remarks;
             existingLMPastValuation.LocationLongitude = dto.LocationLongitude;
             existingLMPastValuation.LocationLatitude = dto.LocationLatitude;
+            existingLMPastValuation.LandMiscellaneousMasterFileId = dto.LandMiscellaneousMasterFileId;
 
             return await _repository.UpdateAsync(existingLMPastValuation);
         }
@@ -119,7 +127,26 @@ private LMPastValuationResponseDto MapToResponseDto(LMPastValuation lmPastValuat
                 RateType = lmPastValuation.RateType,
                 Remarks = lmPastValuation.Remarks,
                 LocationLongitude = lmPastValuation.LocationLongitude,
-                LocationLatitude = lmPastValuation.LocationLatitude
+                LocationLatitude = lmPastValuation.LocationLatitude,
+                LandMiscellaneousMasterFileId = lmPastValuation.LandMiscellaneousMasterFileId,
+                LandMiscellaneousMasterFile = lmPastValuation.LandMiscellaneousMasterFile != null
+                    ? MapMasterFileToDto(lmPastValuation.LandMiscellaneousMasterFile)
+                    : null
+            };
+        }
+
+        private LandMiscellaneousMasterFileDto MapMasterFileToDto(LandMiscellaneousMasterFile masterFile)
+        {
+            return new LandMiscellaneousMasterFileDto
+            {
+                Id = masterFile.Id,
+                MasterFileNo = masterFile.MasterFileNo,
+                MasterFileRefNo = masterFile.MasterFileRefNo,
+                PlanType = masterFile.PlanType,
+                PlanNo = masterFile.PlanNo,
+                RequestingAuthorityReferenceNo = masterFile.RequestingAuthorityReferenceNo,
+                Status = masterFile.Status,
+                Lots = masterFile.Lots
             };
         }
     }
diff --git a/services/LMRentalEvidenceService.cs b/services/LMRentalEvidenceService.cs
index 95813dc..9530339 100644
--- a/services/LMRentalEvidenceService.cs
+++ b/services/LMRentalEvidenceService.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
 using ValuationBackend.Models;
 using ValuationBackend.Models.DTOs;
 using ValuationBackend.Repositories;
@@ -11,10 +12,12 @@ namespace ValuationBackend.Services
     public class LMRentalEvidenceService : ILMRentalEvidenceService
     {
         private readonly ILMRentalEvidenceRepository _repository;
+        private readonly ILandMiscellaneousRepository _masterFileRepository;
 
-        public LMRentalEvidenceService(ILMRentalEvidenceRepository repository)
+        public LMRentalEvidenceService(ILMRentalEvidenceRepository repository, ILandMiscellaneousRepository masterFileRepository)
         {
             _repository = repository;
+            _masterFileRepository = masterFileRepository;
         }
 
         public async Task<IEnumerable<LMRentalEvidenceResponseDto>> GetAllAsync()
@@ -23,18 +26,37 @@ public async Task<IEnumerable<LMRentalEvidenceResponseDto>> GetAllAsync()
             return lmRentalEvidences.Select(MapToResponseDto).ToList();
         }
 
-        public async Task<LMRentalEvidenceResponseDto> GetByIdAsync(int id)
+        public async Task<LMRentalEvidenceResponseDto?> GetByIdAsync(int id)
         {
             var lmRentalEvidence = await _repository.GetByIdAsync(id);
             return lmRentalEvidence == null ? null : MapToResponseDto(lmRentalEvidence);
         }
 
-        public async Task<LMRentalEvidenceResponseDto> GetByReportIdAsync(int reportId)
+        public async Task<LMRentalEvidenceResponseDto?> GetByReportIdAsync(int reportId)
         {
             var lmRentalEvidence = await _repository.GetByReportIdAsync(reportId);
             return lmRentalEvidence == null ? null : MapToResponseDto(lmRentalEvidence);
         }
 
+        // NEW: Methods for foreign key relationship
+        public async Task<IEnumerable<LMRentalEvidenceResponseDto>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            var evidences = await _repository.GetByMasterFileIdAsync(masterFileId);
+            return evidences.Select(MapToResponseDto).ToList();
+        }
+
+        public async Task<IEnumerable<LMRentalEvidenceResponseDto>> GetByMasterFileRefNoAsync(string masterFileRefNo)
+        {
+            var evidences = await _repository.GetByMasterFileRefNoAsync(masterFileRefNo);
+            return evidences.Select(MapToResponseDto).ToList();
+        }
+
+        public async Task<IEnumerable<LMRentalEvidenceResponseDto>> GetAllWithMasterFileDataAsync()
+        {
+            var evidences = await _repository.GetAllWithMasterFileDataAsync();
+            return evidences.Select(MapToResponseDto).ToList();
+        }
+
         public async Task<LMRentalEvidenceResponseDto> CreateAsync(LMRentalEvidenceCreateDto dto)
         {
             // Create a new Report for this LM rental evidence
@@ -48,11 +70,12 @@ public async Task<LMRentalEvidenceResponseDto> CreateAsync(LMRentalEvidenceCreat
             // Add the report first
             report = await _repository.CreateReportAsync(report);
 
-            // Create the LM rental evidence entity from the DTO
-            var lmRentalEvidence = new LMRentalEvidence
+            var entity = new LMRentalEvidence
             {
                 ReportId = report.ReportId,
+                Report = report,
                 MasterFileRefNo = dto.MasterFileRefNo,
+                LandMiscellaneousMasterFileId = dto.LandMiscellaneousMasterFileId,
                 AssessmentNo = dto.AssessmentNo,
                 Owner = dto.Owner,
                 Occupier = dto.Occupier,
@@ -67,8 +90,18 @@ public async Task<LMRentalEvidenceResponseDto> CreateAsync(LMRentalEvidenceCreat
                 Remarks = dto.Remarks
             };
 
-            lmRentalEvidence = await _repository.CreateAsync(lmRentalEvidence);
-            return MapToResponseDto(lmRentalEvidence);
+            // Auto-populate foreign key if not provided but string reference exists
+            if (!entity.LandMiscellaneousMasterFileId.HasValue && !string.IsNullOrEmpty(entity.MasterFileRefNo))
+            {
+                var masterFile = await _masterFileRepository.GetByRefNoAsync(entity.MasterFileRefNo);
+                if (masterFile != null)
+                {
+                    entity.LandMiscellaneousMasterFileId = masterFile.Id;
+                }
+            }
+
+            var createdEntity = await _repository.CreateAsync(entity);
+            return MapToResponseDto(createdEntity);
         }
 
         public async Task<bool> UpdateAsync(int reportId, LMRentalEvidenceUpdateDto dto)
@@ -83,6 +116,7 @@ public async Task<bool> UpdateAsync(int reportId, LMRentalEvidenceUpdateDto dto)
 
             // Update existing LM rental evidence with data from DTO
             existingLMRentalEvidence.MasterFileRefNo = dto.MasterFileRefNo;
+            existingLMRentalEvidence.LandMiscellaneousMasterFileId = dto.LandMiscellaneousMasterFileId;
             existingLMRentalEvidence.AssessmentNo = dto.AssessmentNo;
             existingLMRentalEvidence.Owner = dto.Owner;
             existingLMRentalEvidence.Occupier = dto.Occupier;
@@ -96,6 +130,16 @@ public async Task<bool> UpdateAsync(int reportId, LMRentalEvidenceUpdateDto dto)
             existingLMRentalEvidence.Situation = dto.Situation;
             existingLMRentalEvidence.Remarks = dto.Remarks;
 
+            // Auto-populate foreign key if not provided but string reference exists
+            if (!existingLMRentalEvidence.LandMiscellaneousMasterFileId.HasValue && !string.IsNullOrEmpty(existingLMRentalEvidence.MasterFileRefNo))
+            {
+                var masterFile = await _masterFileRepository.GetByRefNoAsync(existingLMRentalEvidence.MasterFileRefNo);
+                if (masterFile != null)
+                {
+                    existingLMRentalEvidence.LandMiscellaneousMasterFileId = masterFile.Id;
+                }
+            }
+
             return await _repository.UpdateAsync(existingLMRentalEvidence);
         }
 
@@ -111,6 +155,8 @@ private LMRentalEvidenceResponseDto MapToResponseDto(LMRentalEvidence lmRentalEv
                 Id = lmRentalEvidence.Id,
                 ReportId = lmRentalEvidence.ReportId,
                 MasterFileRefNo = lmRentalEvidence.MasterFileRefNo,
+                LandMiscellaneousMasterFileId = lmRentalEvidence.LandMiscellaneousMasterFileId,
+                LandMiscellaneousMasterFile = lmRentalEvidence.LandMiscellaneousMasterFile != null ? MapMasterFileToDto(lmRentalEvidence.LandMiscellaneousMasterFile) : null,
                 AssessmentNo = lmRentalEvidence.AssessmentNo,
                 Owner = lmRentalEvidence.Owner,
                 Occupier = lmRentalEvidence.Occupier,
@@ -125,5 +171,20 @@ private LMRentalEvidenceResponseDto MapToResponseDto(LMRentalEvidence lmRentalEv
                 Remarks = lmRentalEvidence.Remarks
             };
         }
+
+        private LandMiscellaneousMasterFileDto MapMasterFileToDto(LandMiscellaneousMasterFile masterFile)
+        {
+            return new LandMiscellaneousMasterFileDto
+            {
+                Id = masterFile.Id,
+                MasterFileNo = masterFile.MasterFileNo,
+                MasterFileRefNo = masterFile.MasterFileRefNo,
+                PlanType = masterFile.PlanType,
+                PlanNo = masterFile.PlanNo,
+                RequestingAuthorityReferenceNo = masterFile.RequestingAuthorityReferenceNo,
+                Status = masterFile.Status,
+                Lots = masterFile.Lots
+            };
+        }
     }
 }
diff --git a/services/LMSalesEvidenceService.cs b/services/LMSalesEvidenceService.cs
index e528ee9..8c4c491 100644
--- a/services/LMSalesEvidenceService.cs
+++ b/services/LMSalesEvidenceService.cs
@@ -25,10 +25,16 @@ public async Task<IEnumerable<LMSalesEvidenceResponseDto>> GetAllAsync()
 
         public async Task<LMSalesEvidenceResponseDto> GetByIdAsync(int id)
         {
-            var lmSalesEvidence = await _repository.GetByIdAsync(id);
+            var lmSalesEvidence = await _repository.GetByIdWithMasterFileAsync(id);
             return lmSalesEvidence == null ? null : MapToResponseDto(lmSalesEvidence);
         }
 
+        public async Task<IEnumerable<LMSalesEvidenceResponseDto>> GetByMasterFileIdAsync(int masterFileId)
+        {
+            var lmSalesEvidences = await _repository.GetByMasterFileIdAsync(masterFileId);
+            return lmSalesEvidences.Select(MapToResponseDto).ToList();
+        }
+
         public async Task<LMSalesEvidenceResponseDto> GetByReportIdAsync(int reportId)
         {
             var lmSalesEvidence = await _repository.GetByReportIdAsync(reportId);
@@ -72,7 +78,8 @@ public async Task<LMSalesEvidenceResponseDto> CreateAsync(LMSalesEvidenceCreateD
                 LocationLatitude = dto.LocationLatitude,
                 LandRegistryReferences = dto.LandRegistryReferences,
                 Situation = dto.Situation,
-                DescriptionOfProperty = dto.DescriptionOfProperty
+                DescriptionOfProperty = dto.DescriptionOfProperty,
+                LandMiscellaneousMasterFileId = dto.LandMiscellaneousMasterFileId
             };
 
             lmSalesEvidence = await _repository.CreateAsync(lmSalesEvidence);
@@ -111,6 +118,7 @@ public async Task<bool> UpdateAsync(int reportId, LMSalesEvidenceUpdateDto dto)
             existingLMSalesEvidence.LandRegistryReferences = dto.LandRegistryReferences;
             existingLMSalesEvidence.Situation = dto.Situation;
             existingLMSalesEvidence.DescriptionOfProperty = dto.DescriptionOfProperty;
+            existingLMSalesEvidence.LandMiscellaneousMasterFileId = dto.LandMiscellaneousMasterFileId;
 
             return await _repository.UpdateAsync(existingLMSalesEvidence);
         }
@@ -146,7 +154,26 @@ private LMSalesEvidenceResponseDto MapToResponseDto(LMSalesEvidence lmSalesEvide
                 LocationLatitude = lmSalesEvidence.LocationLatitude,
                 LandRegistryReferences = lmSalesEvidence.LandRegistryReferences,
                 Situation = lmSalesEvidence.Situation,
-                DescriptionOfProperty = lmSalesEvidence.DescriptionOfProperty
+                DescriptionOfProperty = lmSalesEvidence.DescriptionOfProperty,
+                LandMiscellaneousMasterFileId = lmSalesEvidence.LandMiscellaneousMasterFileId,
+                LandMiscellaneousMasterFile = lmSalesEvidence.LandMiscellaneousMasterFile != null
+                    ? MapMasterFileToDto(lmSalesEvidence.LandMiscellaneousMasterFile)
+                    : null
+            };
+        }
+
+        private LandMiscellaneousMasterFileDto MapMasterFileToDto(LandMiscellaneousMasterFile masterFile)
+        {
+            return new LandMiscellaneousMasterFileDto
+            {
+                Id = masterFile.Id,
+                MasterFileNo = masterFile.MasterFileNo,
+                MasterFileRefNo = masterFile.MasterFileRefNo,
+                PlanType = masterFile.PlanType,
+                PlanNo = masterFile.PlanNo,
+                RequestingAuthorityReferenceNo = masterFile.RequestingAuthorityReferenceNo,
+                Status = masterFile.Status,
+                Lots = masterFile.Lots
             };
         }
     }
diff --git a/services/PasswordResetService.cs b/services/PasswordResetService.cs
new file mode 100644
index 0000000..d81fbf0
--- /dev/null
+++ b/services/PasswordResetService.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.EntityFrameworkCore;
+using ValuationBackend.Data;
+using ValuationBackend.Models;
+using ValuationBackend.Services;
+
+namespace ValuationBackend.Services
+{
+    public class PasswordResetService
+    {
+        private readonly AppDbContext _context;
+        private readonly IEmailSender _emailSender;
+
+        public PasswordResetService(AppDbContext context, IEmailSender emailSender)
+        {
+            _context = context;
+            _emailSender = emailSender;
+        }
+
+        public async Task RequestPasswordResetAsync(string email)
+        {
+            var user = await _context.Users.FirstOrDefaultAsync(u => u.EmpEmail == email);
+            if (user == null) return; // Don't reveal user existence
+
+            var otp = GenerateOtp();
+            var expiresAt = DateTime.UtcNow.AddMinutes(10);
+
+            var reset = new PasswordReset
+            {
+                Email = email,
+                Otp = otp,
+                ExpiresAt = expiresAt,
+                Used = false
+            };
+            _context.PasswordResets.Add(reset);
+            await _context.SaveChangesAsync();
+
+            var body = $@"<html>
+<head>
+  <meta charset='UTF-8'>
+  <title>Password Reset OTP</title>
+</head>
+<body style='background:#F5DDB3;padding:0;margin:0;font-family:sans-serif;'>
+  <div style='max-width:480px;margin:40px auto;background:#fff;border-radius:12px;box-shadow:0 2px 8px #0001;padding:32px 24px;'>
+    <div style='text-align:center;'>
+      <h2 style='color:#041B4D;margin-bottom:8px;'>Password Reset Request</h2>
+      <p style='color:#6D7986;font-size:16px;margin-bottom:24px;'>We received a request to reset your password for your Valuation Department account.</p>
+      <div style='background:#F5DDB3;border-radius:8px;padding:24px 0;margin-bottom:24px;'>
+        <span style='color:#8B4219;font-size:15px;'>Your One-Time Password (OTP):</span><br>
+        <span style='display:inline-block;font-size:32px;letter-spacing:8px;color:#041B4D;font-weight:bold;margin-top:8px;margin-bottom:8px;'>{otp}</span>
+        <div style='color:#818180;font-size:13px;'>This OTP will expire in 10 minutes.</div>
+      </div>
+      <a href='#' style='display:inline-block;background:#DA8F3E;color:#fff;text-decoration:none;padding:12px 32px;border-radius:6px;font-size:16px;font-weight:600;margin-bottom:24px;'>Reset Password</a>
+      <p style='color:#6D7986;font-size:14px;margin-top:32px;'>If you did not request a password reset, you can safely ignore this email. Someone else might have typed your email address by mistake.</p>
+      <hr style='border:none;border-top:1px solid #E9E9E9;margin:32px 0;'>
+      <div style='color:#C6CFD7;font-size:12px;'>Valuation Department &bull; This is an automated message, please do not reply.</div>
+    </div>
+  </div>
+</body>
+</html>";
+            await _emailSender.SendAsync(email, "Your OTP Code", body);
+        }
+
+        public async Task<bool> VerifyOtpAsync(string email, string otp)
+        {
+            var reset = await _context.PasswordResets
+                .Where(r => r.Email == email && !r.Used && r.ExpiresAt > DateTime.UtcNow)
+                .OrderByDescending(r => r.ExpiresAt)
+                .FirstOrDefaultAsync();
+
+            if (reset == null || reset.Otp != otp) return false;
+            return true;
+        }
+
+        public async Task<bool> ResetPasswordAsync(string email, string otp, string newPassword)
+        {
+            var reset = await _context.PasswordResets
+                .Where(r => r.Email == email && !r.Used && r.ExpiresAt > DateTime.UtcNow)
+                .OrderByDescending(r => r.ExpiresAt)
+                .FirstOrDefaultAsync();
+
+            if (reset == null || reset.Otp != otp) return false;
+
+            var user = await _context.Users.FirstOrDefaultAsync(u => u.EmpEmail == email);
+            if (user == null) return false;
+
+            // Hash the password using HMACSHA512
+            using (var hmac = new System.Security.Cryptography.HMACSHA512())
+            {
+                user.PasswordSalt = hmac.Key;
+                user.PasswordHash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(newPassword));
+            }
+
+            reset.Used = true;
+            await _context.SaveChangesAsync();
+            return true;
+        }
+
+        private string GenerateOtp()
+        {
+            var random = new Random();
+            return random.Next(100000, 999999).ToString();
+        }
+    }
+} 
\ No newline at end of file