DamageAssessment_Backend/DamageAssesmentApi/DamageAssesment.Api.Employees/Controllers/EmployeesController.cs

using DamageAssesment.Api.Employees.Interfaces;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace DamageAssesment.Api.Employees.Controllers
{
    [ApiController]
    public class EmployeesController : ControllerBase
    {

        private IEmployeesProvider EmployeeProvider;

        public EmployeesController(IEmployeesProvider EmployeesProvider)
        {
            this.EmployeeProvider = EmployeesProvider;
        }

        /// <summary>
        /// GET request for retrieving employees.
        /// </summary>
        [Authorize(Roles = "admin")]
        [HttpGet("employees")]
        public async Task<ActionResult> GetEmployeesAsync()
        {

            var result = await EmployeeProvider.GetEmployeesAsync();
            if (result.IsSuccess)
            {
                return Ok(result.Employees);
            }
            return NoContent();

        }

        /// <summary>
        /// GET request for retrieving an employee by ID.
        /// </summary>
        [Authorize(Roles = "admin")]
        [HttpGet("employees/{id}")]
        public async Task<ActionResult> GetEmployeeByIdAsync(int id)
        {

            var result = await EmployeeProvider.GetEmployeeByIdAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.Employee);
            }
            return NotFound();

        }

        /// <summary>
        /// PUT request for updating an existing employee.
        /// </summary>
        /// <param name="Employee">The updated employee object.</param>
        [Authorize(Roles = "admin")]
        [HttpPut("employees/{id}")]
        public async Task<IActionResult> UpdateEmployee(int id, Models.Employee Employee)
        {
            if (Employee != null)
            {
                var result = await this.EmployeeProvider.UpdateEmployeeAsync(id,Employee);
                if (result.IsSuccess)
                {
                    return Ok(result.Employee);
                }
                if (result.ErrorMessage == "Not Found")
                    return NotFound(result.ErrorMessage);

                return BadRequest(result.ErrorMessage);
            }
            return NotFound();
        }

        /// <summary>
        /// POST request for creating a new employee.
        /// </summary>
        /// <param name="Employee">The employee information for creating a new employee.</param>
        [Authorize(Roles = "admin")]
        [HttpPost("employees")]
        public async Task<IActionResult> CreateEmployee(Models.Employee Employee)
        {
            if (Employee != null)
            {
                var result = await this.EmployeeProvider.PostEmployeeAsync(Employee);
                if (result.IsSuccess)
                {
                    return Ok(result.Employee);
                }
                return BadRequest(result.ErrorMessage);
            }
            return CreatedAtRoute("DefaultApi", new { Id = Employee.Id }, Employee);
        }
        /// <summary>
        /// DELETE request for deleting an existing employee.
        /// </summary>
        /// <param name="id">The ID of the employee to be deleted.</param>
        [Authorize(Roles = "admin")]
        [HttpDelete("employees/{id}")]
        public async Task<IActionResult> DeleteEmployee(int id)
        {
            var result = await this.EmployeeProvider.DeleteEmployeeAsync(id);
            if (result.IsSuccess)
            {
                return Ok(result.Employee);
            }
            return NotFound();
        }
    }
}