initial commit

2026-04-15 15:02:32 +02:00
commit 3bfc79e6d9
1380 changed files with 69684 additions and 0 deletions
--- a/Controllers/DomainController.cs
+++ b/Controllers/DomainController.cs
@@ -0,0 +1,230 @@
+using AutoMapper;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.SelfService.Portal.Core.API.Dto.Domain.Add;
+using Microsoft.SelfService.Portal.Core.API.Dto.Domain.Edit;
+using Microsoft.SelfService.Portal.Core.API.Dto.Domain.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 DomainController : Controller
+    {   
+        private readonly IDomainInterface _domainInterface;
+        private readonly IEnvironmentInterface _environmentInterface;
+        private readonly IMapper _mapper;
+        
+        public DomainController(IDomainInterface domainInterface,IEnvironmentInterface environmentInterface, IMapper mapper)
+        {
+            _domainInterface = domainInterface;
+            _environmentInterface = environmentInterface;
+            _mapper = mapper;
+        }
+
+        [HttpGet]
+        [ProducesResponseType(200, Type = typeof(IEnumerable<DomainModel>))]
+        public IActionResult GetDomains()
+        {
+            var domains = _mapper.Map<List<GetDomainDto>>(_domainInterface.GetDomains());
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            return Ok(domains);
+        }
+
+        [HttpGet("{Id}")]
+        [ProducesResponseType(200, Type = typeof(DomainModel))]
+        [ProducesResponseType(400)]
+        public IActionResult GetDomainById(Guid Id)
+        {
+
+            if (!_domainInterface.CheckDomainById(Id))
+                return NotFound();
+
+            var domain = _mapper.Map<GetDomainDetailsDto>(_domainInterface.GetDomainById(Id));
+
+            if(!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            return Ok(domain);
+        }
+
+        [HttpPost]
+        [ProducesResponseType(204)]
+        [ProducesResponseType(400)]
+        public IActionResult AddDomainById([FromBody] AddDomainDto domain)
+        {
+
+            if (domain == null)
+                return BadRequest(ModelState);
+
+            if (_domainInterface.CheckDomainByName(domain.Name))
+            {
+                ModelState.AddModelError("", "Domain already exists");
+                return StatusCode(422, ModelState);
+            }
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            var domainMap = _mapper.Map<DomainModel>(domain);
+
+            if (!_domainInterface.AddDomainById(domainMap))
+            {
+                ModelState.AddModelError("", "Something went wrong while saving");
+                return StatusCode(500, ModelState);
+            }
+
+            //return Ok("Successfully created");
+            return Ok(domainMap.Id);
+        }
+
+        [HttpDelete("{Id}")]
+        [ProducesResponseType(204)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
+        public IActionResult DeleteDomainById(Guid Id)
+        {
+            if (!_domainInterface.CheckDomainById(Id))
+                return NotFound();
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            var domain = _domainInterface.GetDomainById(Id);
+
+            if (!_domainInterface.DeleteDomainById(domain))
+            {
+                ModelState.AddModelError("", "Something went wrong while deleting");
+                return StatusCode(500, ModelState);
+            }
+            return NoContent();
+        }
+
+        [HttpPut("{Id}")]
+        [ProducesResponseType(204)]
+        [ProducesResponseType(400)]
+        [ProducesResponseType(404)]
+        public IActionResult EditDomainById(Guid Id, [FromBody] EditDomainDto domain)
+        {
+            if (domain == null)
+                return BadRequest(ModelState);
+            
+            if (!_domainInterface.CheckDomainById(Id))
+                return NotFound();
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            var domainMap = _mapper.Map<DomainModel>(domain);
+                domainMap.Id = Id;
+            
+            if (!_domainInterface.EditDomainById(domainMap))
+            {
+                ModelState.AddModelError("", "Something went wrong");
+                return StatusCode(500, ModelState);
+            }
+
+            return NoContent();
+        }
+
+        [HttpGet("{Id}/Environments")]
+        [ProducesResponseType(200, Type = typeof(DomainModel))]
+        [ProducesResponseType(400)]
+        public IActionResult GetDomainByIdInEnvironments(Guid Id)
+        {
+
+            if (!_domainInterface.CheckDomainById(Id))
+                return NotFound();
+
+            var domain = _mapper.Map<GetDomainEnvironmentDto>(_domainInterface.GetDomainByIdInEnvironments(Id));
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            return Ok(domain);
+        }
+
+        [HttpPost("{DomainId}/Environment/{EnvironmentId}")]
+        [ProducesResponseType(200, Type = typeof(EnvironmentDomainsModel))]
+        [ProducesResponseType(400)]
+        public IActionResult LinkDomainByIdToEnvironment(Guid DomainId, Guid EnvironmentId)
+        {
+            
+            if(!_domainInterface.CheckDomainById(DomainId))
+                return new NotFoundObjectResult("Domain with Id was not found");
+
+            if(!_environmentInterface.CheckEnvironmentById(EnvironmentId))
+                return new NotFoundObjectResult("Environment with Id was not found");
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            var environmentDomain = new EnvironmentDomainsModel
+            {
+                DomainId = DomainId,
+                Domain = _domainInterface.GetDomainById(DomainId),
+                EnvironmentId = EnvironmentId,
+                Environment = _environmentInterface.GetEnvironmentById(EnvironmentId)
+            };
+
+            var environmentDomainMap = _mapper.Map<EnvironmentDomainsModel>(environmentDomain);
+
+            if (!_domainInterface.LinkDomainByIdToEnvironment(environmentDomainMap))
+            {
+                ModelState.AddModelError("", "Something went wrong while saving");
+                return StatusCode(500, ModelState);
+            }
+
+            return Ok("Successfully created");
+        }
+
+        [HttpDelete("{DomainId}/Environment/{EnvironmentId}")]
+        [ProducesResponseType(200, Type = typeof(EnvironmentDomainsModel))]
+        [ProducesResponseType(400)]
+        public IActionResult UnlinkDomainByIdFromEnvironment(Guid DomainId, Guid EnvironmentId)
+        {
+            if (!_domainInterface.CheckDomainById(DomainId) & !_environmentInterface.CheckEnvironmentById(EnvironmentId))
+                return new NotFoundObjectResult("Domain with Id is not linked to Environment");
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            var environmentDomain = new EnvironmentDomainsModel
+            {
+                DomainId = DomainId,
+                Domain = _domainInterface.GetDomainById(DomainId),
+                EnvironmentId = EnvironmentId,
+                Environment = _environmentInterface.GetEnvironmentById(EnvironmentId)
+            };
+
+            if (!_domainInterface.UnlinkDomainByIdFromEnvironment(environmentDomain))
+            {
+                ModelState.AddModelError("", "Something went wrong while deleting");
+                return StatusCode(500, ModelState);
+            }
+
+            return NoContent();
+        }
+
+        [HttpGet("{Id}/VirtualMachines")]
+        [ProducesResponseType(200, Type = typeof(DomainModel))]
+        [ProducesResponseType(400)]
+        public IActionResult GetVirtualMachinesByDomainId(Guid Id)
+        {
+
+            if (!_domainInterface.CheckDomainById(Id))
+                return NotFound();
+
+            var domain = _mapper.Map<GetDomainVirtualMachineDetailsDto>(_domainInterface.GetVirtualMachinesByDomainId(Id));
+
+            if (!ModelState.IsValid)
+                return BadRequest(ModelState);
+
+            return Ok(domain);
+        }
+    }
+}