Refactor code structure for improved readability and maintainability

Controllers/VirtualMachineController.cs

@@ -1,5 +1,7 @@
-using AutoMapper;
+using AutoMapper;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.SelfService.Portal.Core.API.Dto.VirtualMachine.Add;
+using Microsoft.SelfService.Portal.Core.API.Dto.VirtualMachine.Edit;
 using Microsoft.SelfService.Portal.Core.API.Dto.VirtualMachine.Get;
 using Microsoft.SelfService.Portal.Core.API.Interfaces;
 using Microsoft.SelfService.Portal.Core.API.Models;
@@ -9,13 +11,15 @@ namespace Microsoft.SelfService.Portal.Core.API.Controllers
     [Route("api/[controller]")]
     [ApiController]
     public class VirtualMachineController : Controller
-    {   
+    {
         private readonly IVirtualMachineInterface _virtualmachineInterface;
+        private readonly IDomainInterface _domainInterface;
         private readonly IMapper _mapper;
 
-        public VirtualMachineController(IVirtualMachineInterface virtualmachineInterface, IMapper mapper)
+        public VirtualMachineController(IVirtualMachineInterface virtualmachineInterface, IDomainInterface domainInterface, IMapper mapper)
         {
             _virtualmachineInterface = virtualmachineInterface;
+            _domainInterface = domainInterface;
             _mapper = mapper;
         }
 
@@ -23,12 +27,12 @@ namespace Microsoft.SelfService.Portal.Core.API.Controllers
         [ProducesResponseType(200, Type = typeof(IEnumerable<VirtualMachineModel>))]
         public IActionResult GetVirtualMachines()
         {
-            var virtualmachines = _mapper.Map<List<GetVirtualMachineDto>>(_virtualmachineInterface.GetVirtualMachines());
+            var virtualMachines = _mapper.Map<List<GetVirtualMachineDto>>(_virtualmachineInterface.GetVirtualMachines());
 
             if (!ModelState.IsValid)
                 return BadRequest(ModelState);
 
-            return Ok(virtualmachines);
+            return Ok(virtualMachines);
         }
 
         [HttpGet("{Id}")]
@@ -36,16 +40,161 @@ namespace Microsoft.SelfService.Portal.Core.API.Controllers
         [ProducesResponseType(400)]
         public IActionResult GetVirtualMachineById(Guid Id)
         {
+            if (!_virtualmachineInterface.CheckVirtualMachineById(Id))
+                return NotFound();
+
+            var virtualMachine = _mapper.Map<GetVirtualMachineDetailsDto>(_virtualmachineInterface.GetVirtualMachineById(Id));
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            return Ok(virtualMachine);
+        }
+
+        [HttpPost]
+        [ProducesResponseType(200)]
+        [ProducesResponseType(400)]
+        public IActionResult AddVirtualMachineById([FromBody] AddVirtualMachineDto virtualMachine)
+        {
+            if (virtualMachine == null)
+                return BadRequest(ModelState);
+
+            if (_virtualmachineInterface.CheckVirtualMachineByName(virtualMachine.Name))
+            {
+                ModelState.AddModelError("", "VirtualMachine already exists");
+                return StatusCode(422, ModelState);
+            }
+
+            if (virtualMachine.DomainID.HasValue && !_domainInterface.CheckDomainById(virtualMachine.DomainID.Value))
+            {
+                ModelState.AddModelError("", "Domain does not exist");
+                return BadRequest(ModelState);
+            }
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            var virtualMachineMap = _mapper.Map<VirtualMachineModel>(virtualMachine);
+
+            if (!_virtualmachineInterface.AddVirtualMachineById(virtualMachineMap))
+            {
+                ModelState.AddModelError("", "Something went wrong while saving");
+                return StatusCode(500, ModelState);
+            }
+
+            return Ok(virtualMachineMap.Id);
+        }
+
+        [HttpPut("{Id}")]
+        [ProducesResponseType(204)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
+        public IActionResult EditVirtualMachineById(Guid Id, [FromBody] EditVirtualMachineDto virtualMachine)
+        {
+            if (virtualMachine == null)
+                return BadRequest(ModelState);
 
             if (!_virtualmachineInterface.CheckVirtualMachineById(Id))
                 return NotFound();
 
-            var virtualmachines = _mapper.Map<GetVirtualMachineDetailsDto>(_virtualmachineInterface.GetVirtualMachineById(Id));
-
-            if(!ModelState.IsValid)
+            if (!ModelState.IsValid)
                 return BadRequest(ModelState);
 
-            return Ok(virtualmachines);
+            var existingVirtualMachine = _virtualmachineInterface.GetVirtualMachineById(Id);
+            if (existingVirtualMachine == null)
+                return NotFound();
+
+            existingVirtualMachine.Name = virtualMachine.Name;
+            existingVirtualMachine.ExternalId = virtualMachine.ExternalId;
+            existingVirtualMachine.MetadataJson = virtualMachine.MetadataJson;
+
+            if (!_virtualmachineInterface.EditVirtualMachineById(existingVirtualMachine))
+            {
+                ModelState.AddModelError("", "Something went wrong");
+                return StatusCode(500, ModelState);
+            }
+
+            return NoContent();
+        }
+
+        [HttpPost("{Id}/Domain/{domainId}")]
+        [ProducesResponseType(204)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
+        [ProducesResponseType(409)]
+        public IActionResult LinkVirtualMachineToDomain(Guid Id, Guid domainId)
+        {
+            if (!_virtualmachineInterface.CheckVirtualMachineById(Id))
+                return NotFound();
+
+            if (!_domainInterface.CheckDomainById(domainId))
+                return NotFound();
+
+            var existingVirtualMachine = _virtualmachineInterface.GetVirtualMachineById(Id);
+            if (existingVirtualMachine == null)
+                return NotFound();
+
+            if (existingVirtualMachine.DomainID.HasValue)
+                return Conflict("VirtualMachine is already linked to a domain. Unlink it first.");
+
+            existingVirtualMachine.DomainID = domainId;
+
+            if (!_virtualmachineInterface.EditVirtualMachineById(existingVirtualMachine))
+            {
+                ModelState.AddModelError("", "Something went wrong");
+                return StatusCode(500, ModelState);
+            }
+
+            return NoContent();
+        }
+
+        [HttpDelete("{Id}/Domain")]
+        [ProducesResponseType(204)]
+        [ProducesResponseType(404)]
+        public IActionResult UnlinkVirtualMachineFromDomain(Guid Id)
+        {
+            if (!_virtualmachineInterface.CheckVirtualMachineById(Id))
+                return NotFound();
+
+            var existingVirtualMachine = _virtualmachineInterface.GetVirtualMachineById(Id);
+            if (existingVirtualMachine == null)
+                return NotFound();
+
+            if (!existingVirtualMachine.DomainID.HasValue)
+                return NoContent();
+
+            existingVirtualMachine.DomainID = null;
+
+            if (!_virtualmachineInterface.EditVirtualMachineById(existingVirtualMachine))
+            {
+                ModelState.AddModelError("", "Something went wrong");
+                return StatusCode(500, ModelState);
+            }
+
+            return NoContent();
+        }
+
+        [HttpDelete("{Id}")]
+        [ProducesResponseType(204)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
+        public IActionResult DeleteVirtualMachineById(Guid Id)
+        {
+            if (!_virtualmachineInterface.CheckVirtualMachineById(Id))
+                return NotFound();
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            var virtualMachine = _virtualmachineInterface.GetVirtualMachineById(Id);
+
+            if (!_virtualmachineInterface.DeleteVirtualMachineById(virtualMachine))
+            {
+                ModelState.AddModelError("", "Something went wrong while deleting");
+                return StatusCode(500, ModelState);
+            }
+
+            return NoContent();
         }
     }
 }