API_SQLuedo/API_SQLuedo/API/Controllers/SuccessesController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Dto;
using Model.OrderCriteria;
using Shared;
using Asp.Versioning;

namespace API.Controllers
{
    [Route("api/v{version:apiVersion}/[controller]")]
    [Authorize]
    [ApiVersion("1.0")]
    [ApiController]
    public class SuccessesController : Controller
    {
        private readonly ISuccessService<SuccessDto> _successDataService;

        private readonly ILogger<SuccessesController> _logger;

        public SuccessesController(ISuccessService<SuccessDto> successDataService, ILogger<SuccessesController> logger)
        {
            _successDataService = successDataService;
            _logger = logger;
        }

        [HttpGet("successes/{page:int}/{number:int}/{orderCriteria}")]
        [ProducesResponseType(typeof(SuccessDto), 200)]
        [ProducesResponseType(typeof(string), 204)]
        public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
        {
            var nbUser = _successDataService.GetSuccesses(page, number, orderCriteria).ToList().Count;
            if (nbUser == 0)
            {
                _logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
                return StatusCode(204);
            }

            _logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", nbUser);
            return Ok(_successDataService.GetSuccesses(page, number, orderCriteria));
        }

        [HttpGet("success/user/{id:int}")]
        [ProducesResponseType(typeof(SuccessDto), 200)]
        [ProducesResponseType(typeof(string), 404)]
        public IActionResult GetSuccessByUserId(int id)
        {
            try
            {
                _logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", id);
                return Ok(_successDataService.GetSuccessesByUserId(id));
            }
            catch (ArgumentException)
            {
                _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", id);
                return NotFound();
            }
        }

        [HttpGet("success/inquiry/{id:int}")]
        [ProducesResponseType(typeof(SuccessDto), 200)]
        [ProducesResponseType(typeof(string), 404)]
        public IActionResult GetSuccessByInquiryId(int id)
        {
            try
            {
                _logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.",
                    id);
                return Ok(_successDataService.GetSuccessesByInquiryId(id));
            }
            catch (ArgumentException)
            {
                _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", id);
                return NotFound();
            }
        }

        [HttpDelete("success/{idUser:int}/{idInquiry:int}")]
        [ProducesResponseType(typeof(SuccessDto), 200)]
        [ProducesResponseType(typeof(string), 404)]
        public IActionResult DeleteSuccess(int idUser, int idInquiry)
        {
            var success = _successDataService.DeleteSuccess(idUser, idInquiry);
            if (success)
            {
                _logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", idUser);
                return Ok(success);
            }
            else
            {
                _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", idUser);
                return NotFound();
            }
        }

        [HttpPost]
        [ProducesResponseType(typeof(SuccessDto), 201)]
        [ProducesResponseType(typeof(string), 400)]
        public IActionResult CreateSuccess([FromBody] SuccessDto dto)
        {
            /*if (dto.UserId == null || dto.InquiryId == null)
            {
                return BadRequest();
            }*/
            _logger.LogInformation(
                "[INFORMATION] Un succès a été créé : userId - {userId}, inquiryId - {inquiryId}, isFinished - {isFinished}",
                dto.UserId, dto.InquiryId, dto.IsFinished);
            return Created(nameof(GetSuccesses),
                _successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished));
        }

        [HttpPut("success/{idUser:int}/{idInquiry:int}")]
        [ProducesResponseType(typeof(SuccessDto), 200)]
        [ProducesResponseType(typeof(string), 400)]
        [ProducesResponseType(typeof(string), 404)]
        public IActionResult UpdateSuccess(int idUser, int idInquiry, [FromBody] SuccessDto SuccessDto)
        {
            if (idUser != SuccessDto.UserId || idInquiry != SuccessDto.InquiryId)
            {
                _logger.LogError(
                    "[ERREUR] Problème ID - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.", idUser);
                return BadRequest();
            }
            if (!ModelState.IsValid)
            {
                _logger.LogError(
                    "[ERREUR] Problème controlleur - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
                    idUser);
                return BadRequest();
            }

            if (SuccessDto != null)
            {
                _logger.LogInformation(
                    "[INFORMATION] La mise à jour du succès avec l'id de l'utilisateur {id} a été effectuée", idUser);
                return Ok(_successDataService.UpdateSuccess(idUser,idInquiry, SuccessDto));
            }

            _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id de l'utilisateur {id}.", idUser);
            return NotFound();
        }
    }
}