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

using AutoMapper;
using Microsoft.AspNetCore.Mvc;
using Microsoft.SelfService.Portal.Core.API.Dto.Service.Add;
using Microsoft.SelfService.Portal.Core.API.Dto.Service.Edit;
using Microsoft.SelfService.Portal.Core.API.Dto.Service.Get;
using Microsoft.SelfService.Portal.Core.API.Dto.Service.RoleDefinition;
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 ServiceController : Controller
    {
        private readonly IMapper _mapper;
        private readonly IServiceInterface _serviceInterface;

        public ServiceController(IMapper mapper, IServiceInterface serviceInterface)
        {
            _mapper = mapper;
            _serviceInterface = serviceInterface;
        }

        [HttpGet]
        [ProducesResponseType(200, Type = typeof(IEnumerable<ServiceModel>))]
        public IActionResult GetServices()
        {
            var services = _mapper.Map<List<GetServiceDto>>(_serviceInterface.GetServices());

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

            return Ok(services);
        }

        [HttpGet("{Id}")]
        [ProducesResponseType(200, Type = typeof(ServiceModel))]
        [ProducesResponseType(404)]
        public IActionResult GetServiceById(Guid Id)
        {
            if (!_serviceInterface.CheckServiceById(Id))
                return NotFound();

            var service = _mapper.Map<GetServiceDetailsDto>(_serviceInterface.GetServiceById(Id));

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

            return Ok(service);
        }

        [HttpPost]
        [ProducesResponseType(200)]
        [ProducesResponseType(400)]
        public IActionResult AddServiceById([FromBody] AddServiceDto service)
        {
            if (service == null)
                return BadRequest(ModelState);

            if (_serviceInterface.CheckServiceByName(service.Name))
            {
                ModelState.AddModelError("", "Service already exists");
                return StatusCode(422, ModelState);
            }

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

            var serviceMap = _mapper.Map<ServiceModel>(service);

            if (!_serviceInterface.AddServiceById(serviceMap))
            {
                ModelState.AddModelError("", "Something went wrong while saving");
                return StatusCode(500, ModelState);
            }

            return Ok(serviceMap.Id);
        }

        [HttpPut("{Id}")]
        [ProducesResponseType(204)]
        [ProducesResponseType(400)]
        [ProducesResponseType(404)]
        public IActionResult EditServiceById(Guid Id, [FromBody] EditServiceDto service)
        {
            if (service == null)
                return BadRequest(ModelState);

            if (!_serviceInterface.CheckServiceById(Id))
                return NotFound();

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

            var serviceMap = _mapper.Map<ServiceModel>(service);
            serviceMap.Id = Id;

            if (!_serviceInterface.EditServiceById(serviceMap))
            {
                ModelState.AddModelError("", "Something went wrong");
                return StatusCode(500, ModelState);
            }

            return NoContent();
        }

        [HttpDelete("{Id}")]
        [ProducesResponseType(204)]
        [ProducesResponseType(400)]
        [ProducesResponseType(404)]
        public IActionResult DeleteServiceById(Guid Id)
        {
            if (!_serviceInterface.CheckServiceById(Id))
                return NotFound();

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

            var service = _serviceInterface.GetServiceById(Id);

            if (!_serviceInterface.DeleteServiceById(service))
            {
                ModelState.AddModelError("", "Something went wrong while deleting");
                return StatusCode(500, ModelState);
            }

            return NoContent();
        }

        [HttpGet("{Id}/RoleDefinitions")]
        [ProducesResponseType(200, Type = typeof(IEnumerable<ServiceRoleDefinitionModel>))]
        [ProducesResponseType(404)]
        public IActionResult GetRoleDefinitionsByServiceId(Guid Id)
        {
            if (!_serviceInterface.CheckServiceById(Id))
                return NotFound();

            var roleDefinitions = _serviceInterface.GetRoleDefinitionsByServiceId(Id);
            return Ok(roleDefinitions);
        }

        [HttpPost("{Id}/RoleDefinitions")]
        [ProducesResponseType(200)]
        [ProducesResponseType(400)]
        [ProducesResponseType(404)]
        public IActionResult AddRoleDefinition(Guid Id, [FromBody] AddServiceRoleDefinitionDto roleDefinition)
        {
            if (!_serviceInterface.CheckServiceById(Id))
                return NotFound();

            if (roleDefinition == null)
                return BadRequest(ModelState);

            var service = _serviceInterface.GetServiceById(Id);
            if (service.IsCloudService)
                return BadRequest("Role definitions are not supported for cloud services.");

            if (_serviceInterface.CheckRoleDefinitionKey(Id, roleDefinition.Key))
                return Conflict("Role key already exists for this service.");

            var roleDefinitionModel = new ServiceRoleDefinitionModel
            {
                ServiceId = Id,
                Key = roleDefinition.Key,
                Name = roleDefinition.Name,
                Description = roleDefinition.Description
            };

            if (!_serviceInterface.AddRoleDefinition(roleDefinitionModel))
            {
                ModelState.AddModelError("", "Something went wrong while saving role definition");
                return StatusCode(500, ModelState);
            }

            return Ok(roleDefinitionModel.Id);
        }

        [HttpPut("{Id}/RoleDefinitions/{RoleDefinitionId}")]
        [ProducesResponseType(204)]
        [ProducesResponseType(400)]
        [ProducesResponseType(404)]
        public IActionResult EditRoleDefinition(Guid Id, Guid RoleDefinitionId, [FromBody] EditServiceRoleDefinitionDto roleDefinition)
        {
            if (!_serviceInterface.CheckServiceById(Id))
                return NotFound();

            if (!_serviceInterface.CheckRoleDefinitionById(RoleDefinitionId))
                return NotFound();

            if (roleDefinition == null)
                return BadRequest(ModelState);

            var service = _serviceInterface.GetServiceById(Id);
            if (service.IsCloudService)
                return BadRequest("Role definitions are not supported for cloud services.");

            if (_serviceInterface.CheckRoleDefinitionKey(Id, roleDefinition.Key, RoleDefinitionId))
                return Conflict("Role key already exists for this service.");

            var roleDefinitionModel = _serviceInterface.GetRoleDefinitionById(RoleDefinitionId);
            if (roleDefinitionModel.ServiceId != Id)
                return BadRequest("Role definition does not belong to this service.");

            roleDefinitionModel.Key = roleDefinition.Key;
            roleDefinitionModel.Name = roleDefinition.Name;
            roleDefinitionModel.Description = roleDefinition.Description;

            if (!_serviceInterface.EditRoleDefinition(roleDefinitionModel))
            {
                ModelState.AddModelError("", "Something went wrong while updating role definition");
                return StatusCode(500, ModelState);
            }

            return NoContent();
        }

        [HttpDelete("{Id}/RoleDefinitions/{RoleDefinitionId}")]
        [ProducesResponseType(204)]
        [ProducesResponseType(404)]
        public IActionResult DeleteRoleDefinition(Guid Id, Guid RoleDefinitionId)
        {
            if (!_serviceInterface.CheckServiceById(Id))
                return NotFound();

            if (!_serviceInterface.CheckRoleDefinitionById(RoleDefinitionId))
                return NotFound();

            var roleDefinitionModel = _serviceInterface.GetRoleDefinitionById(RoleDefinitionId);
            if (roleDefinitionModel.ServiceId != Id)
                return BadRequest("Role definition does not belong to this service.");

            if (!_serviceInterface.DeleteRoleDefinition(roleDefinitionModel))
            {
                ModelState.AddModelError("", "Something went wrong while deleting role definition");
                return StatusCode(500, ModelState);
            }

            return NoContent();
        }
    }
}