Feat: Login and password with Jwt

jwt-auth-api.Api/src/jwt-auth-api.Api/Controllers/AuthController.cs

@@ -0,0 +1,42 @@
+using jwt_auth_api.Api.ViewModel.Login;
+using jwt_auth_api.Application.Service;
+using Microsoft.AspNetCore.Identity.Data;
+using Microsoft.AspNetCore.Mvc;
+
+namespace jwt_auth_api.Api.Controllers
+{
+    [ApiController]
+    [Route("api/[controller]")]
+    public class AuthController : ControllerBase
+    {
+        private readonly AuthService _authService;
+        public AuthController(AuthService authService)
+        {
+            _authService = authService;
+        }
+
+        [HttpPost("login")]
+        public IActionResult Login([FromBody] AuthLoginRequest request)
+        {
+            try
+            {
+                string retorno = _authService.Login(request.Email, request.Password);
+                AuthLoginResponse response = new AuthLoginResponse();
+                response.Token = retorno;
+                response.Message = "Login realizado com sucesso";
+                return Ok(response);
+            }
+            catch (Exception ex) 
+            {
+                return Unauthorized(new { Message = ex.Message });
+            }       
+        }
+
+        [HttpPost("Logout")]
+        public IActionResult Logout()
+        {
+            string result = _authService.Logout();
+            return Ok(result);
+        }
+    }
+}

jwt-auth-api.Api/src/jwt-auth-api.Api/Controllers/PersonController.cs

@@ -1,54 +1,92 @@
-using jwt_auth_api.Application.Service;
-using jwt_auth_api.Core;
+using jwt_auth_api.Api.ViewModel;
+using jwt_auth_api.Api.ViewModel.PersonViewModel;
+using jwt_auth_api.Application.Service;
+using jwt_auth_api.Core.Users;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 
-// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860
-
 namespace jwt_auth_api.Api.Controllers
 {
     [Route("api/[controller]")]
     [ApiController]
+    [Authorize]
     public class PersonController : ControllerBase
     {
-        private readonly ServicePerson  _servicePerson;
-        public PersonController(ServicePerson servicePerson)
+        private readonly PersonService  _servicePerson;
+        public PersonController(PersonService servicePerson)
         {
             _servicePerson = servicePerson;
         }
         [HttpGet]
-        public List<Person> Get()
+        public IActionResult Get()
         {
-            return _servicePerson.Read();
+            List<Person> person = _servicePerson.Read();
+            List<PersonViewModel> listViewModel = new List<PersonViewModel>();
+            foreach (var p in person)
+            {
+                listViewModel.Add(new PersonViewModel
+                {
+                    Id = p.Id,
+                    FirstName = p.FirstName,
+                    LastName = p.LastName
+                }); 
+            }
+            return Ok(listViewModel);
         }
 
-
         [HttpGet("{id}")]
-        public Person Get(Guid id)
+        public ActionResult<PersonViewModel> Get(int id)
         {
-            return _servicePerson.ReadById(id);
+            Person person = _servicePerson.ReadById(id);
+            if (person == null)
+                return NotFound();
+
+            var personViewModel = new PersonViewModel
+            {
+                Id = person.Id,
+                FirstName = person.FirstName,
+                LastName = person.LastName
+            };
+
+            return personViewModel;
         }
 
+
         [HttpGet("exist/{id}")]
-        public bool Exist(Guid id)
+        public IActionResult Exist(int id)
         {
-            return _servicePerson.Exists(id);
+            var response = _servicePerson.Exists(id);
+            return Ok(response);
         }
 
         [HttpPost]
-        public void Post([FromBody] Person model)
+        public IActionResult Post([FromBody] PersonViewModel viewModel)
         {
+            Person model = new Person
+            {
+                FirstName = viewModel.FirstName,
+                LastName = viewModel.LastName   
+            };
             _servicePerson.Create(model);
+            return CreatedAtAction(nameof(Get), new { id = model.Id }, model);
         }
-
-
+
         [HttpPut("{id}")]
-        public void Put(Guid id, [FromBody] Person model)
+        public IActionResult Put(int id, [FromBody] PersonViewModel viewModel)
         {
+            Person model = new Person
+            {
+                Id = id,
+                FirstName = viewModel.FirstName,
+                LastName = viewModel.LastName
+            };
+
             _servicePerson.Update(model);
+            return Ok(model);  
         }
 
         [HttpDelete("{id}")]
-        public StatusCodeResult Delete(Guid id)
+        public StatusCodeResult Delete(int id)
         {
             try
             {

jwt-auth-api.Api/src/jwt-auth-api.Api/Controllers/UsuarioController.cs

@@ -0,0 +1,107 @@
+using jwt_auth_api.Api.ViewModel.UsersViewModel;
+using jwt_auth_api.Application.Service;
+using jwt_auth_api.Core.Users;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace jwt_auth_api.Api.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    [Authorize]
+    public class UsuarioController : ControllerBase
+    {
+        private readonly UsuarioService _serviceUsuario;
+        private readonly PersonService _servicePerson;
+
+        public UsuarioController(UsuarioService serviceUsuario, PersonService servicePerson)
+        {
+            _serviceUsuario = serviceUsuario;
+            _servicePerson = servicePerson;
+        }
+
+        [HttpGet]
+        public List<UserResponseViewModel> Get()
+        {
+            List<Usuario> usuarios =  _serviceUsuario.Read();
+            List<UserResponseViewModel> listViewModel = new List<UserResponseViewModel>();
+            foreach (var usuario in usuarios)
+            {
+                listViewModel.Add(new UserResponseViewModel
+                {
+                    Id = usuario.Id,
+                    Email = usuario.Email,
+                    CreatedAt = usuario.CreatedAt,
+                    Person = _servicePerson.ReadById(usuario.PersonId)
+                }); //gerei o token no senha do usuario, depois é validar com jwt
+            }
+            return listViewModel;
+        }
+
+
+        [HttpGet("{id}")]
+        public UserResponseViewModel Get(int id)
+        {
+            Usuario user = _serviceUsuario.ReadById(id);
+            UserResponseViewModel userResponseViewModel = new UserResponseViewModel
+            {
+                Id = user.Id,
+                Email = user.Email,
+                CreatedAt = user.CreatedAt,
+                Person = _servicePerson.ReadById(user.PersonId)
+            };
+            return  userResponseViewModel;
+        }
+
+        [HttpGet("exist/{id}")]
+        public bool Exist(int id)
+        {
+            return  _serviceUsuario.Exists(id);
+        }
+
+        [HttpPost]
+        public IActionResult Post([FromBody] UserRequestViewModel viewModel)
+        {
+            Usuario model = new Usuario
+            {
+                Email = viewModel.Email,
+                Password = viewModel.Password,
+                PersonId = viewModel.PersonId
+            };
+             _serviceUsuario.Create(model);
+            return CreatedAtAction(nameof(Get), new { id = model.Id }, model);
+        }
+
+
+        [HttpPut("{id}")]
+        public void Put(int id, [FromBody] UserPasswordViewModel model)
+        {
+            if (id != model.Id)
+            {
+                throw new ArgumentException("O ID do objeto User não é igual ao ID da URL.");
+            }
+
+            Usuario userToUpdate = new Usuario();
+            userToUpdate.Id = model.Id;
+            userToUpdate.Password = model.Password;
+            _serviceUsuario.Update(userToUpdate);
+        }
+
+        [HttpDelete("{id}")]
+        public StatusCodeResult Delete(int id)
+        {
+            try
+            {
+                this. _serviceUsuario.Delete(id);
+                StatusCodeResult result = new StatusCodeResult(204);
+                return result;
+            }
+            catch (Exception)
+            {
+                StatusCodeResult result = new StatusCodeResult(500);
+                return result;
+            }
+
+        }
+    }
+}

jwt-auth-api.Api/src/jwt-auth-api.Api/Extensions/AuthenticationExtensions.cs

@@ -0,0 +1,45 @@
+using jwt_auth_api.Application.Auth.Config;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.IdentityModel.Tokens;
+using System.Security.Claims;
+using System.Text;
+
+namespace jwt_auth_api.Api.Extensions
+{
+    public static class AuthenticationExtensions
+    {
+        public static IServiceCollection AddAuthenticationConfiguration(this IServiceCollection services, IConfiguration configuration)
+        {
+            // Configurações de Token
+            var tokenConfigurations = configuration.GetSection("TokenConfigurations");
+            var issuer = tokenConfigurations["Issuer"];
+            var audience = tokenConfigurations["Audience"];
+            var secret = tokenConfigurations["Secret"]
+                        ?? throw new InvalidOperationException("JWT Secret não configurado.");
+            services.Configure<TokenConfiguration>(tokenConfigurations);
+
+            services.AddAuthentication(option =>
+            {
+                option.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+                option.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+            })
+               .AddJwtBearer(options =>
+               {
+                   options.TokenValidationParameters = new TokenValidationParameters
+                   {
+                       ValidateIssuer = true,
+                       ValidateAudience = true,
+                       ValidateLifetime = true,
+                       ValidateIssuerSigningKey = true,
+                       ValidIssuer = issuer,
+                       ValidAudience = audience,
+                       IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret)),
+                       RoleClaimType = ClaimTypes.Role
+                   };
+               });
+
+            return services;
+        }
+    }
+}

jwt-auth-api.Api/src/jwt-auth-api.Api/Extensions/DependencyInjectionExtensions.cs

@@ -1,17 +1,25 @@
-using jwt_auth_api.Application.Service;
+using jwt_auth_api.Application.Auth.Tools;
+using jwt_auth_api.Application.Service;
+using jwt_auth_api.Core.Users;
 using jwt_auth_api.Infrastructure.Repositories;
 using jwt_auth_api.Infrastructure.Repositories.Interfaces;
+using Microsoft.AspNetCore.Identity;
 
 namespace jwt_auth_api.Api.Extensions
 {
     public static class DependencyInjectionExtensions
     {
         public static IServiceCollection AddAppDependencies(this IServiceCollection services)
         {
-            services.AddScoped<ServicePerson>();
+            services.AddScoped<PersonService>();
+            services.AddScoped<UsuarioService>();
+            services.AddScoped<AuthService>();
+            services.AddScoped<TokenGenerator, TokenGenerator>();
+            services.AddScoped<PasswordHasher<Usuario>>();
 
             // ===== Repositories =====
-            services.AddScoped(typeof(IRepositoriy<>), typeof(BaseRepository<>));
+            services.AddScoped(typeof(IRepositoriy<>), typeof(GeneriRepository<>));
+            services.AddScoped<AuthRepository>();
             return services;
         }
 

jwt-auth-api.Api/src/jwt-auth-api.Api/Program.cs

@@ -1,6 +1,9 @@
 using jwt_auth_api.Api.Extensions;
 using jwt_auth_api.Infrastructure.Context;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.OpenApi;
+using Scalar.AspNetCore;
+
 
 var builder = WebApplication.CreateBuilder(args);
 
@@ -11,8 +14,7 @@
 builder.Services.AddControllers();
 // Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
 builder.Services.AddOpenApi();
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
+
 
 //===== Database =====
 builder.Services.AddDbContext<ApplicationDbContext>(options =>
@@ -23,19 +25,19 @@
 
 //===== Extensions =====
 builder.Services.AddAppDependencies();
+builder.Services.AddAuthenticationConfiguration(builder.Configuration);
+
 var app = builder.Build();
 
 // Configure the HTTP request pipeline.
 if (app.Environment.IsDevelopment())
 {
+    app.MapScalarApiReference();
     app.MapOpenApi();
-
-    app.UseSwagger();
-    app.UseSwaggerUI();
 }
 
 app.UseHttpsRedirection();
-
+app.UseAuthentication();
 app.UseAuthorization();
 
 app.MapControllers();