Merge pull request #70 from PasinduPrabhashitha/async-messaging

pasindu-pr · web-flow · commit 26933ef93ce6 · 2023-04-22T08:14:13.000+05:30
Async messaging
diff --git a/src/services/Florage.Authentication/ConfigurationsRegistration/JwtConfiguration.cs b/src/services/Florage.Authentication/ConfigurationsRegistration/JwtConfiguration.cs
@@ -8,18 +8,9 @@ public static class JwtConfiguration
     {
         public static IServiceCollection JwtConfigurationRegistration(this IServiceCollection services, IConfiguration configuration)
         {
-            services.AddAuthentication(options =>
-            {
-                options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
-                options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
-                options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
-            })
-
-            // Adding Jwt Bearer
+            services.AddAuthentication(defaultScheme: JwtBearerDefaults.AuthenticationScheme)
             .AddJwtBearer(options =>
             {
-                options.SaveToken = true;
-                options.RequireHttpsMetadata = false;
                 options.TokenValidationParameters = new TokenValidationParameters()
                 {
                     ValidateIssuer = true,
diff --git a/src/services/Florage.Authentication/ConfigurationsRegistration/RegisterIdentity.cs b/src/services/Florage.Authentication/ConfigurationsRegistration/RegisterIdentity.cs
@@ -1,20 +1,19 @@
-﻿using AspNetCore.Identity.Mongo;
-using AspNetCore.Identity.Mongo.Model;
+﻿using Florage.Authentication.Models;
+using Microsoft.AspNetCore.Identity;
 
 namespace Florage.Authentication.ConfigurationsRegistration
 {
     public static class RegisterIdentity
     {
         public static IServiceCollection ConfigureIdentityServices(this IServiceCollection services, IConfiguration configuration)
-        {
-            services.AddIdentityMongoDbProvider<MongoUser, MongoRole>(identity =>
-            {
-                identity.Password.RequiredLength = 8;
-            },
-                mongo =>
-            {
-                mongo.ConnectionString = configuration.GetConnectionString("DefaultConnection");
-            });
+        { 
+            services.AddIdentity<ApplicationUser, ApplicationRole>()
+                .AddMongoDbStores<ApplicationUser, ApplicationRole, Guid>
+                (
+                    configuration.GetConnectionString("DefaultConnection"),
+                    "Auth"
+                )
+                .AddDefaultTokenProviders();
 
             return services;
         }
diff --git a/src/services/Florage.Authentication/Contracts/IAuthService.cs b/src/services/Florage.Authentication/Contracts/IAuthService.cs
@@ -0,0 +1,13 @@
+﻿using Florage.Authentication.Dtos;
+using Florage.Authentication.Responses;
+using Microsoft.AspNetCore.Identity;
+
+namespace Florage.Authentication.Contracts
+{
+    public interface IAuthService
+    {
+        public Task<IdentityResult> RegisterAsync(UserRegisterDto userRegisterDto);
+        public Task<UserTokenResponse> LoginAsync(UserLoginDto userLoginDto);
+        public bool ValidateToken(string token);
+    }
+}
diff --git a/src/services/Florage.Authentication/Contracts/IUserService.cs b/src/services/Florage.Authentication/Contracts/IUserService.cs
@@ -1,13 +1,10 @@
-﻿using Florage.Authentication.Dtos;
-using Florage.Authentication.Responses;
-using Microsoft.AspNetCore.Identity;
+﻿using Microsoft.AspNetCore.Identity;
 
 namespace Florage.Authentication.Contracts
 {
     public interface IUserService
     {
-        public Task<IdentityResult> RegisterAsync(UserRegisterDto userRegisterDto);
-        public Task<UserTokenResponse> LoginAsync(UserLoginDto userLoginDto);
-        public bool ValidateToken(string token);
+        Task<IdentityResult> AddAdminRole();
+        Task<IdentityResult> AddUserToAdminRole(string userId);
     }
 }
diff --git a/src/services/Florage.Authentication/Controllers/AuthController.cs b/src/services/Florage.Authentication/Controllers/AuthController.cs
@@ -7,16 +7,19 @@
 namespace Florage.Authentication.Controllers
 {
     [Route("api/[controller]")]
-    [ApiController]
+    [ApiController]    
     public class AuthController : ControllerBase
     {
 
-        private readonly IUserService _userService;
 
-        public AuthController(IUserService userService)
+        //[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme, Roles = ("admin"))]
+
+        private readonly IAuthService _userService;
+
+        public AuthController(IAuthService userService)
         {
             _userService = userService;
-        } 
+        }
 
         [HttpPost]
         [Route("register")]
diff --git a/src/services/Florage.Authentication/Controllers/UserController.cs b/src/services/Florage.Authentication/Controllers/UserController.cs
@@ -0,0 +1,48 @@
+﻿using Florage.Authentication.Contracts;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Florage.Authentication.Controllers
+{
+    [Route("api/users")]
+    [ApiController]
+    public class UserController : ControllerBase
+    {
+        private readonly IUserService _userService;
+
+        public UserController(IUserService userService)
+        {
+            _userService = userService;
+        }
+
+        [HttpPost]
+        [Route("add-admin")]
+        public async Task<ActionResult<IdentityResult>> AddRole()
+        {
+            IdentityResult identityResult = await _userService.AddAdminRole();
+
+            if(identityResult != null && identityResult.Succeeded)
+            {
+                return Ok(identityResult);
+            }
+
+            return BadRequest(identityResult);
+        }
+
+        [Authorize]
+        [HttpPost]
+        [Route("assign-admin")]
+        public async Task<ActionResult<IdentityResult>> AssignAdminRoleToUser(string userId)
+        {
+            IdentityResult identityResult = await _userService.AddUserToAdminRole(userId);
+
+            if (identityResult.Succeeded)
+            {
+                return Ok(identityResult);
+            }
+
+            return BadRequest(identityResult);
+        }
+    }
+}
diff --git a/src/services/Florage.Authentication/Florage.Authentication.csproj b/src/services/Florage.Authentication/Florage.Authentication.csproj
@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AspNetCore.Identity.Mongo" Version="8.3.3" />
+    <PackageReference Include="AspNetCore.Identity.MongoDbCore" Version="3.1.2" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.15" />
     <PackageReference Include="Microsoft.AspNetCore.Identity" Version="2.2.0" />
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.15.1" />
diff --git a/src/services/Florage.Authentication/Models/ApplicationRole.cs b/src/services/Florage.Authentication/Models/ApplicationRole.cs
@@ -0,0 +1,15 @@
+﻿using AspNetCore.Identity.MongoDbCore.Models;
+
+namespace Florage.Authentication.Models
+{
+    public class ApplicationRole : MongoIdentityRole<Guid>
+	{
+		public ApplicationRole() : base()
+		{
+		}
+
+		public ApplicationRole(string roleName) : base(roleName)
+		{
+		}
+	}
+}
diff --git a/src/services/Florage.Authentication/Models/ApplicationUser.cs b/src/services/Florage.Authentication/Models/ApplicationUser.cs
@@ -0,0 +1,15 @@
+﻿using AspNetCore.Identity.MongoDbCore.Models;
+
+namespace Florage.Authentication.Models
+{
+    public class ApplicationUser: MongoIdentityUser<Guid>
+    {
+        public ApplicationUser(): base()
+        { 
+        }
+
+        public ApplicationUser(string userName, string email) : base(userName, email)
+        {
+        }
+    }
+}
diff --git a/src/services/Florage.Authentication/Program.cs b/src/services/Florage.Authentication/Program.cs
@@ -1,20 +1,54 @@
 using Florage.Authentication.Configurations;
 using Florage.Authentication.ConfigurationsRegistration;
 using Florage.Authentication.Contracts;
-using Florage.Authentication.Services;
+using Florage.Authentication.Services; 
+using Microsoft.OpenApi.Models;
 
 var builder = WebApplication.CreateBuilder(args); 
 
 builder.Services.AddControllers(); 
 builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();  
-builder.Services.AddScoped<IUserService, UserService>();
+builder.Services.AddSwaggerGen(); 
+builder.Services.AddScoped<IAuthService, AuthService>();
+builder.Services.AddTransient<IUserService, UserService>();
+
+builder.Services.AddSwaggerGen(option =>
+{
+    option.SwaggerDoc("v1", new OpenApiInfo { Title = "Florage Auth API", Version = "v1" });
+    option.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
+    {
+        Name = "Authorization",
+        Type = SecuritySchemeType.ApiKey,
+        Scheme = "Bearer",
+        BearerFormat = "JWT",
+        In = ParameterLocation.Header,
+        Description = "JWT Authorization header using the Bearer scheme. \r\n\r\n Enter 'Bearer' [space] and then your token in the text input below.\r\n\r\nExample: \"Bearer 1safsfsdfdfd\"",
+    });
+    option.AddSecurityRequirement(new OpenApiSecurityRequirement
+    {
+        {
+            new OpenApiSecurityScheme
+            {
+                Reference = new OpenApiReference
+                {
+                    Type=ReferenceType.SecurityScheme,
+                    Id="Bearer"
+                }
+            },
+            new string[]{}
+        }
+    });
+});
 
 JwtConfiguration.JwtConfigurationRegistration(builder.Services, builder.Configuration);
 RegisterIdentity.ConfigureIdentityServices(builder.Services, builder.Configuration);
 
 var app = builder.Build();
 
+app.UseAuthentication();
+app.UseAuthorization();
+
+
 if (app.Environment.IsDevelopment())
 {
     app.UseSwagger();
@@ -23,7 +57,6 @@
 
 app.UseHttpsRedirection();
 
-app.UseAuthorization();
 
 app.MapControllers();
 
diff --git a/src/services/Florage.Authentication/Services/AuthService.cs b/src/services/Florage.Authentication/Services/AuthService.cs
@@ -0,0 +1,105 @@
+﻿using Florage.Authentication.Contracts;
+using Florage.Authentication.Dtos;
+using Florage.Authentication.Models;
+using Florage.Authentication.Responses;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.IdentityModel.Tokens;
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+
+namespace Florage.Authentication.Services
+{
+    public class AuthService : IAuthService
+    {
+        private readonly UserManager<ApplicationUser> _userManager; 
+        private readonly IConfiguration _configuration;
+
+        public AuthService(UserManager<ApplicationUser> userManager, IConfiguration configuration)
+        {
+            _userManager = userManager; 
+            _configuration = configuration;
+        }
+
+        public async Task<UserTokenResponse> LoginAsync(UserLoginDto userLoginDto)
+        {
+            UserTokenResponse userToken;
+                
+            var user = await _userManager.FindByEmailAsync(userLoginDto.Email); 
+            
+            if (user != null && await _userManager.CheckPasswordAsync(user, userLoginDto.Password))
+            {
+                var userRoles = await _userManager.GetRolesAsync(user);
+
+                var authClaims = new List<Claim>
+                {
+                    new Claim(ClaimTypes.Name, user.UserName),
+                    new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
+                };
+
+                foreach (var userRole in userRoles)
+                {
+                    authClaims.Add(new Claim(ClaimTypes.Role, userRole));
+                } 
+
+                String tokenReponse = new JwtSecurityTokenHandler().WriteToken(GetToken(authClaims));
+                return userToken = new UserTokenResponse { Token = tokenReponse, Success = true };
+            }
+
+            userToken = new UserTokenResponse { Token = null, Success = false, Message = "Email or password is incorrect." };
+            
+            return userToken;
+        }
+
+        public async Task<IdentityResult> RegisterAsync(UserRegisterDto userRegisterDto)
+        {
+            ApplicationUser user = new ApplicationUser(userRegisterDto.Email, userRegisterDto.Email);
+     
+            IdentityResult identityResult = await _userManager.CreateAsync(user, userRegisterDto.Password);
+            return identityResult;
+        }
+        
+        private JwtSecurityToken GetToken(List<Claim> authClaims)
+        {
+            var authSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JWT:Secret"]));
+
+            var token = new JwtSecurityToken(
+                issuer: _configuration["JWT:ValidIssuer"],
+                audience: _configuration["JWT:ValidAudience"],
+                expires: DateTime.Now.AddHours(3),
+                claims: authClaims,
+                signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256)
+                );
+
+            return token;
+        }
+
+        public bool ValidateToken(string token)
+        {
+            if (token == null)
+                return false;
+
+            var tokenHandler = new JwtSecurityTokenHandler();
+            var key = Encoding.ASCII.GetBytes(_configuration["Jwt:Secret"]);
+            try
+            {
+                tokenHandler.ValidateToken(token, new TokenValidationParameters
+                {
+                    ValidateIssuerSigningKey = true,
+                    IssuerSigningKey = new SymmetricSecurityKey(key),
+                    ValidateIssuer = false,
+                    ValidIssuer = _configuration["Jwt:ValidIssuer"],
+                    ValidateAudience = false,
+                    ValidAudience = _configuration["Jwt:ValidAudience"], 
+                    ClockSkew = TimeSpan.Zero
+                }, out SecurityToken validatedToken); 
+                
+                return true;
+            }
+            catch
+            { 
+                return false;
+            }
+        }
+    }
+}
diff --git a/src/services/Florage.Authentication/Services/UserService.cs b/src/services/Florage.Authentication/Services/UserService.cs
diff --git a/src/services/Florage.Authentication/appsettings.json b/src/services/Florage.Authentication/appsettings.json
diff --git a/src/services/Florage.Shared/Configurations/JwtConfiguration.cs b/src/services/Florage.Shared/Configurations/JwtConfiguration.cs
diff --git a/src/services/Florage.Shared/Configurations/SwaggerAuthorizationConfigurations.cs b/src/services/Florage.Shared/Configurations/SwaggerAuthorizationConfigurations.cs
diff --git a/src/services/Florage.Shared/Florage.Shared.csproj b/src/services/Florage.Shared/Florage.Shared.csproj

Original file line number	Diff line number	Diff line change
`@@ -8,18 +8,9 @@ public static class JwtConfiguration`
`8`	`8`	`{`
`9`	`9`	`public static IServiceCollection JwtConfigurationRegistration(this IServiceCollection services, IConfiguration configuration)`
`10`	`10`	`{`
`11`		`- services.AddAuthentication(options =>`
`12`		`- {`
`13`		`- options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;`
`14`		`- options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;`
`15`		`- options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;`
`16`		`- })`
`17`		`-`
`18`		`- // Adding Jwt Bearer`
	`11`	`+ services.AddAuthentication(defaultScheme: JwtBearerDefaults.AuthenticationScheme)`
`19`	`12`	`.AddJwtBearer(options =>`
`20`	`13`	`{`
`21`		`- options.SaveToken = true;`
`22`		`- options.RequireHttpsMetadata = false;`
`23`	`14`	`options.TokenValidationParameters = new TokenValidationParameters()`
`24`	`15`	`{`
`25`	`16`	`ValidateIssuer = true,`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,10 @@`
`1`		`-using Florage.Authentication.Dtos;`
`2`		`-using Florage.Authentication.Responses;`
`3`		`-using Microsoft.AspNetCore.Identity;`
	`1`	`+using Microsoft.AspNetCore.Identity;`
`4`	`2`
`5`	`3`	`namespace Florage.Authentication.Contracts`
`6`	`4`	`{`
`7`	`5`	`public interface IUserService`
`8`	`6`	`{`
`9`		`- public Task<IdentityResult> RegisterAsync(UserRegisterDto userRegisterDto);`
`10`		`- public Task<UserTokenResponse> LoginAsync(UserLoginDto userLoginDto);`
`11`		`- public bool ValidateToken(string token);`
	`7`	`+ Task<IdentityResult> AddAdminRole();`
	`8`	`+ Task<IdentityResult> AddUserToAdminRole(string userId);`
`12`	`9`	`}`
`13`	`10`	`}`