Microsoft.SelfService.Portal.Core.API/Controllers/VirtualMachineController.cs

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;

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, IDomainInterface domainInterface, IMapper mapper)
        {
            _virtualmachineInterface = virtualmachineInterface;
            _domainInterface = domainInterface;
            _mapper = mapper;
        }

        [HttpGet]
        [ProducesResponseType(200, Type = typeof(IEnumerable<VirtualMachineModel>))]
        public IActionResult GetVirtualMachines()
        {
            var virtualMachines = _mapper.Map<List<GetVirtualMachineDto>>(_virtualmachineInterface.GetVirtualMachines());

            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            return Ok(virtualMachines);
        }

        [HttpGet("{Id}")]
        [ProducesResponseType(200, Type = typeof(VirtualMachineModel))]
        [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();

            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            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();
        }
    }
}