mycorerepository/MyCore/Controllers/AuthenticationController.cs

using MyCore.Interfaces.DTO;
using MyCore.Service.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Net.Http.Headers;
using NSwag.Annotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Threading.Tasks;
using Mqtt.Client.AspNetCore.Services;
using MyCore.Services.MyControlPanel;
using MyCore.Services;
using MyCore.Services.Devices;

namespace MyCore.Service.Controllers
{
    /// <summary>
    /// Authentication controller
    /// </summary>
    [ApiController, Route("api/[controller]")]
    [Authorize]
    [OpenApiTag("Authentication", Description = "Authentication management")]
    public class AuthenticationController : ControllerBase
    {
        private readonly ILogger<AuthenticationController> _logger;
        private readonly TokensService _tokensService;
        private readonly DeviceDatabaseService _DeviceDatabaseService;
        private readonly ProviderDatabaseService _ProviderDatabaseService;
        private readonly LocationDatabaseService _LocationDatabaseService;
        private readonly UserDatabaseService _UserDatabaseService;
        private readonly ActionService _ActionService;
        private readonly AutomationDatabaseService _AutomationDatabaseService;
        private readonly IMqttClientService _mqttClientService;
        //private readonly IMqttOnlineClientService _mqttOnlineClientService;

        public AuthenticationController(ILogger<AuthenticationController> logger, TokensService tokensService, DeviceDatabaseService DeviceDatabaseService, ProviderDatabaseService ProviderDatabaseService, LocationDatabaseService LocationDatabaseService, UserDatabaseService UserDatabaseService, ActionService ActionService, AutomationDatabaseService AutomationDatabaseService, MqttClientServiceProvider provider)//, MqttClientOnlineServiceProvider onlineProvider)
        {
            _logger = logger;
            _tokensService = tokensService;
            _DeviceDatabaseService = DeviceDatabaseService;
            _ProviderDatabaseService = ProviderDatabaseService;
            _LocationDatabaseService = LocationDatabaseService;
            _UserDatabaseService = UserDatabaseService;
            _ActionService = ActionService;
            _AutomationDatabaseService = AutomationDatabaseService;
            _mqttClientService = provider.MqttClientService;
            //_mqttOnlineClientService = onlineProvider.MqttOnlineClientService;
        }

        private ActionResult<LoginDTO> Authenticate(string email, string password)
        {
            try
            {
                var token = _tokensService.Authenticate(email.ToLower(), password);

                // Set user token ? 
                var user = _UserDatabaseService.GetByEmail(email.ToLower());

                if (user != null) {
                    System.Console.WriteLine($"Init userId for MqqClientService ! {user.Email}");
                    MqttClientService.SetServices(_DeviceDatabaseService, _ProviderDatabaseService, _LocationDatabaseService, _ActionService, _AutomationDatabaseService, user.Id);
                }

                return Ok(token);
            }
            /*catch (UnauthorizedAccessException ex)
            {
                _logger?.LogError(ex, $"Authentication error for user '{email}': unauthorized access");
                return Unauthorized(ex);
            }*/
            catch (Exception ex)
            {
                _logger?.LogError(ex, $"Authenticate error for user '{email}'");
                return Problem($"Authenticate error for user '{email}': {ex.Message}");
            }
        }

        /// <summary>
        /// Authenticate with form parameters (used by Swagger test client)
        /// </summary>
        /// <param name="tokenRequest">Swagger token request</param>
        /// <returns>Token descriptor</returns>
        [AllowAnonymous]
        [HttpPost("Token")]
        [Consumes("application/x-www-form-urlencoded")]
        [SwaggerResponse(HttpStatusCode.OK, typeof(LoginDTO), Description = "Success")]
        [SwaggerResponse(HttpStatusCode.Unauthorized, typeof(string), Description = "Invalid credentials")]
        [SwaggerResponse(HttpStatusCode.InternalServerError, typeof(string), Description = "Error")]
        public ActionResult<LoginDTO> AuthenticateWithForm([FromForm] SwaggerTokenRequest tokenRequest)
        {
            return Authenticate(tokenRequest.username, tokenRequest.password);
        }

        /// <summary>
        /// Authenticate with Json parameters (used by most clients)
        /// </summary>
        /// <param name="login">Login DTO</param>
        /// <returns>Token descriptor</returns>
        [AllowAnonymous]
        [HttpPost("Authenticate")]
        [Consumes("application/json")]
        [SwaggerResponse(HttpStatusCode.OK, typeof(LoginDTO), Description = "Success")]
        [SwaggerResponse(HttpStatusCode.Unauthorized, typeof(string), Description = "Invalid credentials")]
        [SwaggerResponse(HttpStatusCode.InternalServerError, typeof(string), Description = "Error")]
        public ActionResult<LoginDTO> AuthenticateWithJson([FromBody] LoginDTO login)
        {
            return Authenticate(login.Email.ToLower(), login.Password);
        }
    }
}