Refactor code structure for improved readability and maintainability

Controllers/ServiceController.cs

@@ -1,8 +1,9 @@
-using AutoMapper;
+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.Events;
-using Microsoft.SelfService.Portal.Core.API.Events.Interfaces;
+using Microsoft.SelfService.Portal.Core.API.Dto.Service.RoleDefinition;
 using Microsoft.SelfService.Portal.Core.API.Interfaces;
 using Microsoft.SelfService.Portal.Core.API.Models;
 
@@ -32,20 +33,210 @@ namespace Microsoft.SelfService.Portal.Core.API.Controllers
 
             return Ok(services);
         }
-        
+
         [HttpGet("{Id}")]
         [ProducesResponseType(200, Type = typeof(ServiceModel))]
+        [ProducesResponseType(404)]
         public IActionResult GetServiceById(Guid Id)
         {
-            if(!_serviceInterface.CheckServiceById(Id))
+            if (!_serviceInterface.CheckServiceById(Id))
                 return NotFound();
 
             var service = _mapper.Map<GetServiceDetailsDto>(_serviceInterface.GetServiceById(Id));
-            
-            if(!ModelState.IsValid)
+
+            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();
+        }
     }
 }