diff --git a/src/Presentation/Browl.Client/Program.cs b/src/Presentation/Browl.Client/Program.cs
index 6ef6a48..2b11c7d 100644
--- a/src/Presentation/Browl.Client/Program.cs
+++ b/src/Presentation/Browl.Client/Program.cs
@@ -1,15 +1,18 @@
using Browl.Client;
+
using Microsoft.AspNetCore.Components.Web;
using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
+
using MudBlazor.Services;
var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add
("#app");
+
builder.RootComponents.Add("head::after");
builder.Services.AddScoped(sp => new HttpClient
{
- BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
+ BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});
builder.Services.AddMudServices();
diff --git a/src/Presentation/Browl.Client/Properties/launchSettings.json b/src/Presentation/Browl.Client/Properties/launchSettings.json
index cdba9c3..a07c0d5 100644
--- a/src/Presentation/Browl.Client/Properties/launchSettings.json
+++ b/src/Presentation/Browl.Client/Properties/launchSettings.json
@@ -3,7 +3,7 @@
"windowsAuthentication": false,
"anonymousAuthentication": true,
"iisExpress": {
- "applicationUrl": "http://localhost:1408",
+ "applicationUrl": "http://localhost:1400",
"sslPort": 44398
}
},
@@ -18,10 +18,10 @@
},
"Browl": {
"commandName": "Project",
- "dotnetRunMessages": "true",
+ "dotnetRunMessages": true,
"launchBrowser": true,
"inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}",
- "applicationUrl": "https://localhost:1408",
+ "applicationUrl": "https://localhost:1400",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Development"
}
diff --git a/src/Presentation/Browl.Client/Resources/Accounts/JwtTokenResponseResource.cs b/src/Presentation/Browl.Client/Resources/Accounts/JwtTokenResponseResource.cs
new file mode 100644
index 0000000..9ce9824
--- /dev/null
+++ b/src/Presentation/Browl.Client/Resources/Accounts/JwtTokenResponseResource.cs
@@ -0,0 +1,6 @@
+namespace Browl.Client.Resources.Accounts;
+
+public class JwtTokenResponseResource
+{
+ public string AccessToken { get; set; }
+}
diff --git a/src/Presentation/Browl.Client/Resources/Accounts/LoginResource.cs b/src/Presentation/Browl.Client/Resources/Accounts/LoginResource.cs
new file mode 100644
index 0000000..5376e7d
--- /dev/null
+++ b/src/Presentation/Browl.Client/Resources/Accounts/LoginResource.cs
@@ -0,0 +1,7 @@
+namespace Browl.Client.Resources.Accounts;
+
+public class LoginResource
+{
+ public string Email { get; set; }
+ public string Password { get; set; }
+}
diff --git a/src/Presentation/Browl.Client/Resources/Accounts/LoginValidationResource.cs b/src/Presentation/Browl.Client/Resources/Accounts/LoginValidationResource.cs
new file mode 100644
index 0000000..b3d107a
--- /dev/null
+++ b/src/Presentation/Browl.Client/Resources/Accounts/LoginValidationResource.cs
@@ -0,0 +1,31 @@
+using FluentValidation;
+
+namespace Browl.Client.Resources.Accounts;
+
+public class LoginValidationResource : AbstractValidator
+{
+ public LoginValidationResource()
+ {
+ RuleFor(_ => _.Email)
+ .NotEmpty()
+ .EmailAddress()
+ .WithMessage("Invalid Email");
+
+ RuleFor(x => x.Password).NotEmpty().WithMessage("Invalid Credentials")
+ .MinimumLength(6).WithMessage("Invalid Credentials")
+ .MaximumLength(16).WithMessage("Invalid Credentials")
+ .Matches(@"[A-Z]+").WithMessage("Invalid Credentials")
+ .Matches(@"[a-z]+").WithMessage("Invalid Credentials")
+ .Matches(@"[0-9]+").WithMessage("Invalid Credentials")
+ .Matches(@"[\@\!\?\*\.]+").WithMessage("Invalid Credentials");
+ }
+
+ public Func>> ValidateValue => async (model, propertyName) =>
+ {
+ var result =
+ await ValidateAsync(ValidationContext.CreateWithOptions((LoginResource)model, x => x.IncludeProperties(propertyName)));
+ if (result.IsValid)
+ return Array.Empty();
+ return result.Errors.Select(e => e.ErrorMessage);
+ };
+}
diff --git a/src/Presentation/Browl.Client/Resources/Accounts/RegistrationResource.cs b/src/Presentation/Browl.Client/Resources/Accounts/RegistrationResource.cs
new file mode 100644
index 0000000..b35be19
--- /dev/null
+++ b/src/Presentation/Browl.Client/Resources/Accounts/RegistrationResource.cs
@@ -0,0 +1,10 @@
+namespace Browl.Client.Resources.Accounts;
+
+public class RegistrationResource
+{
+ public string FirstName { get; set; }
+ public string LastName { get; set; }
+ public string Email { get; set; }
+ public string Password { get; set; }
+ public string ConfirmPassword { get; set; }
+}
diff --git a/src/Presentation/Browl.Client/Resources/Accounts/RegistrationValidationResource.cs b/src/Presentation/Browl.Client/Resources/Accounts/RegistrationValidationResource.cs
new file mode 100644
index 0000000..6f8f0f9
--- /dev/null
+++ b/src/Presentation/Browl.Client/Resources/Accounts/RegistrationValidationResource.cs
@@ -0,0 +1,57 @@
+using FluentValidation;
+
+using System.Text.RegularExpressions;
+
+namespace Browl.Client.Resources.Accounts;
+
+
+public class RegistrationValidationResource : AbstractValidator
+{
+ private readonly HttpClient _httpClient;
+ public RegistrationValidationResource(HttpClient httpClient)
+ {
+ RuleFor(x => x.FirstName).NotEmpty();
+ RuleFor(x => x.LastName).NotEmpty();
+ RuleFor(x => x.Email).NotEmpty().EmailAddress()
+ .MustAsync(async (value, CancellationToken) => await UniqueEmail(value))
+ .When(_ => !string.IsNullOrEmpty(_.Email) && Regex.IsMatch(_.Email, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z", RegexOptions.IgnoreCase), ApplyConditionTo.CurrentValidator)
+ .WithMessage("Email Is Already Exist");
+ RuleFor(x => x.Password).NotEmpty().WithMessage("Your password cannot be empty")
+ .MinimumLength(6).WithMessage("Your password length must be at least 6.")
+ .MaximumLength(16).WithMessage("Your password length must not exceed 16.")
+ .Matches(@"[A-Z]+").WithMessage("Your password must contain at least one uppercase letter.")
+ .Matches(@"[a-z]+").WithMessage("Your password must contain at least one lowercase letter.")
+ .Matches(@"[0-9]+").WithMessage("Your password must contain at least one number.")
+ .Matches(@"[\@\!\?\*\.]+").WithMessage("Your password must contain at least one (@!? *.).");
+ RuleFor(x => x.ConfirmPassword).Equal(_ => _.Password).WithMessage("'Confirm Password' must be equal 'Password'");
+ _httpClient = httpClient;
+
+ }
+
+ public Func>> ValidateValue => async (model, propertyName) =>
+ {
+ var result =
+ await ValidateAsync(ValidationContext.CreateWithOptions((RegistrationResource)model, x => x.IncludeProperties(propertyName)));
+ if (result.IsValid)
+ return Array.Empty();
+ return result.Errors.Select(e => e.ErrorMessage);
+ };
+
+ private async Task UniqueEmail(string email)
+ {
+ try
+ {
+ var url = $"/api/User/unique-user-email?email={email}";
+ var response = await _httpClient.GetAsync(url);
+ response.EnsureSuccessStatusCode();
+
+ var content = await response.Content.ReadAsStringAsync();
+ return Convert.ToBoolean(content);
+ }
+ catch (Exception ex)
+ {
+ return false;
+ }
+
+ }
+}
diff --git a/src/Presentation/Browl.Client/Shared/MainLayout.razor b/src/Presentation/Browl.Client/Shared/MainLayout.razor
index a758d02..2cb10e2 100644
--- a/src/Presentation/Browl.Client/Shared/MainLayout.razor
+++ b/src/Presentation/Browl.Client/Shared/MainLayout.razor
@@ -1,39 +1,45 @@
-@inherits LayoutComponentBase
+@using System.Security.Claims;
+@inherits LayoutComponentBase
-
-
-
-
-
-
-
- Browl
-
-
-
-
-
-
- @Body
-
-
+
+
+ JWt Auth Demo
+
+
+ Wether ForeCast
+
+
+
+
+
+ @UserDisplyaName(context.User.Claims.ToList())
+
+
+ Login
+ Registration
+
+
+
+
+
+ @Body
+
-
-@code {
- bool _drawerOpen = true;
-
- void DrawerToggle()
- {
- _drawerOpen = !_drawerOpen;
- }
+@code{
+ private string UserDisplyaName(List claims)
+ {
+ var firstName = claims.Where(_ => _.Type == "FirstName").Select(_ => _.Value).FirstOrDefault();
+ var lastName = claims.Where(_ => _.Type == "LastName").Select(_ => _.Value).FirstOrDefault();
+ if(!string.IsNullOrEmpty(firstName) || !string.IsNullOrEmpty(lastName))
+ {
+ return $"{firstName} {lastName}";
+ }
+ var email = claims.Where(_ => _.Type == "Email").Select(_ => _.Value).FirstOrDefault();
+ return email;
+ }
}
\ No newline at end of file
diff --git a/src/Presentation/Browl.Client/Shared/MainLayout.razor.css b/src/Presentation/Browl.Client/Shared/MainLayout.razor.css
new file mode 100644
index 0000000..c865427
--- /dev/null
+++ b/src/Presentation/Browl.Client/Shared/MainLayout.razor.css
@@ -0,0 +1,81 @@
+.page {
+ position: relative;
+ display: flex;
+ flex-direction: column;
+}
+
+main {
+ flex: 1;
+}
+
+.sidebar {
+ background-image: linear-gradient(180deg, rgb(5, 39, 103) 0%, #3a0647 70%);
+}
+
+.top-row {
+ background-color: #f7f7f7;
+ border-bottom: 1px solid #d6d5d5;
+ justify-content: flex-end;
+ height: 3.5rem;
+ display: flex;
+ align-items: center;
+}
+
+ .top-row ::deep a, .top-row ::deep .btn-link {
+ white-space: nowrap;
+ margin-left: 1.5rem;
+ text-decoration: none;
+ }
+
+ .top-row ::deep a:hover, .top-row ::deep .btn-link:hover {
+ text-decoration: underline;
+ }
+
+ .top-row ::deep a:first-child {
+ overflow: hidden;
+ text-overflow: ellipsis;
+ }
+
+@media (max-width: 640.98px) {
+ .top-row:not(.auth) {
+ display: none;
+ }
+
+ .top-row.auth {
+ justify-content: space-between;
+ }
+
+ .top-row ::deep a, .top-row ::deep .btn-link {
+ margin-left: 0;
+ }
+}
+
+@media (min-width: 641px) {
+ .page {
+ flex-direction: row;
+ }
+
+ .sidebar {
+ width: 250px;
+ height: 100vh;
+ position: sticky;
+ top: 0;
+ }
+
+ .top-row {
+ position: sticky;
+ top: 0;
+ z-index: 1;
+ }
+
+ .top-row.auth ::deep a:first-child {
+ flex: 1;
+ text-align: right;
+ width: 0;
+ }
+
+ .top-row, article {
+ padding-left: 2rem !important;
+ padding-right: 1.5rem !important;
+ }
+}
diff --git a/src/Presentation/Browl.Client/Shared/NavMenu.razor b/src/Presentation/Browl.Client/Shared/NavMenu.razor
index 0de1a85..519bbed 100644
--- a/src/Presentation/Browl.Client/Shared/NavMenu.razor
+++ b/src/Presentation/Browl.Client/Shared/NavMenu.razor
@@ -1,3 +1,39 @@
-
- Home
-
+
+
+
+
+@code {
+ private bool collapseNavMenu = true;
+
+ private string? NavMenuCssClass => collapseNavMenu ? "collapse" : null;
+
+ private void ToggleNavMenu()
+ {
+ collapseNavMenu = !collapseNavMenu;
+ }
+}
diff --git a/src/Presentation/Browl.Client/Shared/NavMenu.razor.css b/src/Presentation/Browl.Client/Shared/NavMenu.razor.css
new file mode 100644
index 0000000..604b7a1
--- /dev/null
+++ b/src/Presentation/Browl.Client/Shared/NavMenu.razor.css
@@ -0,0 +1,68 @@
+.navbar-toggler {
+ background-color: rgba(255, 255, 255, 0.1);
+}
+
+.top-row {
+ height: 3.5rem;
+ background-color: rgba(0,0,0,0.4);
+}
+
+.navbar-brand {
+ font-size: 1.1rem;
+}
+
+.oi {
+ width: 2rem;
+ font-size: 1.1rem;
+ vertical-align: text-top;
+ top: -2px;
+}
+
+.nav-item {
+ font-size: 0.9rem;
+ padding-bottom: 0.5rem;
+}
+
+ .nav-item:first-of-type {
+ padding-top: 1rem;
+ }
+
+ .nav-item:last-of-type {
+ padding-bottom: 1rem;
+ }
+
+ .nav-item ::deep a {
+ color: #d7d7d7;
+ border-radius: 4px;
+ height: 3rem;
+ display: flex;
+ align-items: center;
+ line-height: 3rem;
+ }
+
+.nav-item ::deep a.active {
+ background-color: rgba(255,255,255,0.25);
+ color: white;
+}
+
+.nav-item ::deep a:hover {
+ background-color: rgba(255,255,255,0.1);
+ color: white;
+}
+
+@media (min-width: 641px) {
+ .navbar-toggler {
+ display: none;
+ }
+
+ .collapse {
+ /* Never collapse the sidebar for wide screens */
+ display: block;
+ }
+
+ .nav-scrollable {
+ /* Allow sidebar to scroll for tall menus */
+ height: calc(100vh - 3.5rem);
+ overflow-y: auto;
+ }
+}
diff --git a/src/Presentation/Browl.Client/Shared/Providers/CustomAuthProvider.cs b/src/Presentation/Browl.Client/Shared/Providers/CustomAuthProvider.cs
new file mode 100644
index 0000000..e417d09
--- /dev/null
+++ b/src/Presentation/Browl.Client/Shared/Providers/CustomAuthProvider.cs
@@ -0,0 +1,52 @@
+using Blazored.LocalStorage;
+
+using Microsoft.AspNetCore.Components.Authorization;
+
+using System.Security.Claims;
+using System.Text.Json;
+
+namespace Browl.Client.Shared.Providers;
+
+public class CustomAuthProvider : AuthenticationStateProvider
+{
+ private readonly ILocalStorageService _localStorageService;
+ public CustomAuthProvider(ILocalStorageService localStorageService)
+ {
+ _localStorageService = localStorageService;
+ }
+ public override async Task GetAuthenticationStateAsync()
+ {
+ var jwtToken = await _localStorageService.GetItemAsync("jwt-access-token");
+ if (string.IsNullOrEmpty(jwtToken))
+ {
+ return new AuthenticationState(
+ new ClaimsPrincipal(new ClaimsIdentity()));
+ }
+
+ return new AuthenticationState(new ClaimsPrincipal(
+ new ClaimsIdentity(ParseClaimsFromJwt(jwtToken), "JwtAuth")));
+ }
+
+ private static IEnumerable ParseClaimsFromJwt(string jwt)
+ {
+ var payload = jwt.Split('.')[1];
+ var jsonBytes = ParseBase64WithoutPadding(payload);
+ var keyValuePairs = JsonSerializer.Deserialize>(jsonBytes);
+ return keyValuePairs.Select(kvp => new Claim(kvp.Key, kvp.Value.ToString()));
+ }
+
+ private static byte[] ParseBase64WithoutPadding(string base64)
+ {
+ switch (base64.Length % 4)
+ {
+ case 2: base64 += "=="; break;
+ case 3: base64 += "="; break;
+ }
+ return Convert.FromBase64String(base64);
+ }
+
+ public void NotifyAuthState()
+ {
+ NotifyAuthenticationStateChanged(GetAuthenticationStateAsync());
+ }
+}
diff --git a/src/Presentation/Browl.Client/Shared/Providers/CustomHttpHandler.cs b/src/Presentation/Browl.Client/Shared/Providers/CustomHttpHandler.cs
new file mode 100644
index 0000000..13fb2fb
--- /dev/null
+++ b/src/Presentation/Browl.Client/Shared/Providers/CustomHttpHandler.cs
@@ -0,0 +1,28 @@
+using Blazored.LocalStorage;
+
+namespace Browl.Client.Shared.Providers;
+
+public class CustomHttpHandler : DelegatingHandler
+{
+ private readonly ILocalStorageService _localStorageService;
+ public CustomHttpHandler(ILocalStorageService localStorageService)
+ {
+ _localStorageService = localStorageService;
+ }
+ protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+ {
+ if (request.RequestUri.AbsolutePath.ToLower().Contains("login") ||
+ request.RequestUri.AbsolutePath.ToLower().Contains("register"))
+ {
+ return await base.SendAsync(request, cancellationToken);
+ }
+
+ var token = await _localStorageService.GetItemAsync("jwt-access-token");
+ if (!string.IsNullOrEmpty(token))
+ {
+ request.Headers.Add("Authorization", $"Bearer {token}");
+ }
+
+ return await base.SendAsync(request, cancellationToken);
+ }
+}
diff --git a/src/Presentation/Browl.Client/_Imports.razor b/src/Presentation/Browl.Client/_Imports.razor
index a4b490a..ed50256 100644
--- a/src/Presentation/Browl.Client/_Imports.razor
+++ b/src/Presentation/Browl.Client/_Imports.razor
@@ -9,3 +9,7 @@
@using MudBlazor
@using Browl.Client
@using Browl.Client.Shared
+@using Browl.Client.Resources.Accounts
+@using FluentValidation
+@using Blazored.LocalStorage
+@using Microsoft.AspNetCore.Components.Authorization
\ No newline at end of file
diff --git a/src/Presentation/Browl.Client/wwwroot/css/app.min.css b/src/Presentation/Browl.Client/wwwroot/css/app.min.css
index 9e21629..468e12e 100644
--- a/src/Presentation/Browl.Client/wwwroot/css/app.min.css
+++ b/src/Presentation/Browl.Client/wwwroot/css/app.min.css
@@ -485,6 +485,9 @@ video {
--tw-backdrop-saturate: ;
--tw-backdrop-sepia: ;
}
+.collapse {
+ visibility: collapse;
+}
.m-10 {
margin: 2.5rem;
}
@@ -492,19 +495,27 @@ video {
margin-left: auto;
margin-right: auto;
}
-.my-16 {
- margin-top: 4rem;
- margin-bottom: 4rem;
-}
.mb-8 {
margin-bottom: 2rem;
}
+.ml-2 {
+ margin-left: 0.5rem;
+}
+.ml-auto {
+ margin-left: auto;
+}
+.mr-2 {
+ margin-right: 0.5rem;
+}
.mt-8 {
margin-top: 2rem;
}
.flex {
display: flex;
}
+.justify-center {
+ justify-content: center;
+}
.rounded-md {
border-radius: 0.375rem;
}
@@ -519,6 +530,10 @@ video {
.p-4 {
padding: 1rem;
}
+.px-3 {
+ padding-left: 0.75rem;
+ padding-right: 0.75rem;
+}
.px-4 {
padding-left: 1rem;
padding-right: 1rem;
@@ -527,8 +542,8 @@ video {
padding-top: 3rem;
padding-bottom: 3rem;
}
-.pt-16 {
- padding-top: 4rem;
+.ps-3 {
+ padding-inline-start: 0.75rem;
}
.text-white {
--tw-text-opacity: 1;
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Browl.Service.AuthSecurity.API.csproj b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Browl.Service.AuthSecurity.API.csproj
new file mode 100644
index 0000000..d823ef5
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Browl.Service.AuthSecurity.API.csproj
@@ -0,0 +1,21 @@
+
+
+
+ net7.0
+ enable
+ enable
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/ApiConfig.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/ApiConfig.cs
new file mode 100644
index 0000000..d5ffe29
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/ApiConfig.cs
@@ -0,0 +1,57 @@
+using Browl.Service.AuthSecurity.API.Service;
+using Browl.Service.AuthSecurity.API.Services;
+using Browl.Service.AuthSecurity.API.Services.Interfaces;
+
+namespace Browl.Service.AuthSecurity.API.Configuration;
+
+public static class ApiConfig
+{
+ public static IServiceCollection AddApiConfiguration(this IServiceCollection services, IWebHostEnvironment hostEnvironment, IConfiguration configuration)
+ {
+ _ = services.AddControllers();
+ _ = services.AddEndpointsApiExplorer();
+
+ services.AddScoped();
+ services.AddScoped();
+
+ services.AddCors(options =>
+ {
+ options.AddPolicy(name: "BrowlCors",
+ policy =>
+ {
+ policy.WithOrigins("https://localhost:7219")
+ .AllowAnyHeader()
+ .AllowAnyMethod();
+ });
+ });
+
+ var builder = new ConfigurationBuilder()
+ .SetBasePath(hostEnvironment.ContentRootPath)
+ .AddJsonFile("appsettings.json", true, true)
+ .AddJsonFile($"appsettings.{hostEnvironment.EnvironmentName}.json", true, true)
+ .AddEnvironmentVariables();
+
+ if (hostEnvironment.IsDevelopment())
+ {
+ _ = builder.AddUserSecrets();
+ }
+
+ return services;
+ }
+
+ public static IApplicationBuilder UseApiConfiguration(this IApplicationBuilder app, IWebHostEnvironment env)
+ {
+
+ app.UseHttpsRedirection();
+ app.UseRouting();
+ app.UseAuthentication();
+ app.UseAuthorization();
+ app.UseCors("BrowlCors");
+ app.UseEndpoints(endpoints =>
+ {
+ var unused = endpoints.MapControllers();
+ });
+
+ return app;
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/IdentityConfig.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/IdentityConfig.cs
new file mode 100644
index 0000000..0be7d64
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/IdentityConfig.cs
@@ -0,0 +1,64 @@
+using System.Text;
+
+using Browl.Service.AuthSecurity.API.Data;
+using Browl.Service.AuthSecurity.API.Entities;
+
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.IdentityModel.Tokens;
+
+namespace Browl.Service.AuthSecurity.API.Configuration;
+
+public static class IdentityConfig
+{
+ public static IServiceCollection AddIdentityConfiguration(this IServiceCollection services,
+ IConfiguration configuration)
+ {
+ var unused3 = services.AddDbContext(options =>
+ options.UseSqlServer(configuration.GetConnectionString("DefaultConnection")));
+
+ var unused2 = services.AddDefaultIdentity()
+ .AddRoles()
+ .AddEntityFrameworkStores()
+ .AddDefaultTokenProviders();
+
+ // JWT
+
+ var appSettingsSection = configuration.GetSection("AppSettings");
+ var unused1 = services.Configure(appSettingsSection);
+
+ var appSettings = appSettingsSection.Get();
+ var key = Encoding.ASCII.GetBytes(appSettings.Secret);
+
+ var unused = services.AddAuthentication(options =>
+ {
+ options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
+ options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
+ }).AddJwtBearer(bearerOptions =>
+ {
+ bearerOptions.RequireHttpsMetadata = true;
+ bearerOptions.SaveToken = true;
+ bearerOptions.TokenValidationParameters = new TokenValidationParameters
+ {
+ ValidateIssuerSigningKey = true,
+ IssuerSigningKey = new SymmetricSecurityKey(key),
+ ValidateIssuer = true,
+ ValidateAudience = true,
+ ValidAudience = appSettings.ValidOn,
+ ValidIssuer = appSettings.Issuer
+ };
+ });
+
+ return services;
+ }
+
+ public static IApplicationBuilder UseIdentityConfiguration(this IApplicationBuilder app)
+ {
+ _ = app.UseAuthentication();
+ _ = app.UseAuthorization();
+
+ return app;
+ }
+
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/SwaggerConfig.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/SwaggerConfig.cs
new file mode 100644
index 0000000..95b6564
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Configuration/SwaggerConfig.cs
@@ -0,0 +1,34 @@
+using Microsoft.OpenApi.Models;
+
+namespace Browl.Service.AuthSecurity.API.Configuration;
+
+public static class SwaggerConfig
+{
+ public static IServiceCollection AddSwaggerConfiguration(this IServiceCollection services)
+ {
+ var unused = services.AddSwaggerGen(c =>
+ {
+ c.SwaggerDoc("v1", new OpenApiInfo()
+ {
+ Title = "Browl Service AuthSecurity API",
+ Description = "This API guarantees the security and proper authentication of users in the application.",
+ Contact = new OpenApiContact() { Name = "Rondinele Guimarães", Email = "dev@cia3r.com.br" },
+ License = new OpenApiLicense() { Name = "MIT", Url = new Uri("https://opensource.org/licenses/MIT") }
+ });
+
+ });
+
+ return services;
+ }
+
+ public static IApplicationBuilder UseSwaggerConfiguration(this IApplicationBuilder app)
+ {
+ var unused1 = app.UseSwagger();
+ var unused = app.UseSwaggerUI(c =>
+ {
+ c.SwaggerEndpoint("/swagger/v1/swagger.json", "v1");
+ });
+
+ return app;
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/AuthController.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/AuthController.cs
new file mode 100644
index 0000000..96fde85
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/AuthController.cs
@@ -0,0 +1,99 @@
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+
+using Browl.Service.AuthSecurity.API.Controllers.Base;
+using Browl.Service.AuthSecurity.API.Entities;
+using Browl.Service.AuthSecurity.API.Services.Interfaces;
+
+using Microsoft.AspNetCore.Authentication;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+
+namespace Browl.Service.AuthSecurity.API.Controllers;
+
+
+[Route("api/identity/auth")]
+public class AuthController : MainController
+{
+ private readonly SignInManager _signInManager;
+ private readonly UserManager _userManager;
+ private readonly AppSettings _appSettings;
+ private readonly IAuthenticateService _authenticateService;
+ public AuthController(SignInManager signInManager,
+ UserManager userManager,
+ IOptions appSettings,
+ IAuthenticateService authenticateService)
+ {
+ _signInManager = signInManager;
+ _userManager = userManager;
+ _appSettings = appSettings.Value;
+ _authenticateService = authenticateService;
+ }
+
+ [HttpPost("new-account")]
+ public async Task Register(UserRegister userRegister)
+ {
+ if (!ModelState.IsValid)
+ {
+ return CustomResponse(ModelState);
+ }
+
+ var identityUser = new User
+ {
+ UserName = userRegister.UserName,
+ FirstName = userRegister.FirstName,
+ LastName = userRegister.LastName,
+ UserNameChangeLimit = userRegister.UserNameChangeLimit,
+ ProfilePicture = userRegister.ProfilePicture,
+ Email = userRegister.Email,
+ EmailConfirmed = true,
+ Password = userRegister.Password,
+ PasswordConfirmation = userRegister.PasswordConfirmation
+ };
+
+ var result = await _userManager.CreateAsync(identityUser, userRegister.Password);
+
+ if (result.Succeeded)
+ {
+ return CustomResponse(await _authenticateService.GenerateJWT(userRegister.Email));
+ }
+
+ foreach (var error in result.Errors)
+ {
+ AddErrorProcessing(error.Description);
+ }
+
+ return CustomResponse();
+ }
+
+
+ [HttpPost("authenticate")]
+ public async Task Login(UserLogin usuarioLogin)
+ {
+ if (!ModelState.IsValid)
+ {
+ return CustomResponse(ModelState);
+ }
+
+ var result = await _signInManager.PasswordSignInAsync(usuarioLogin.Email, usuarioLogin.Password,
+ false, true);
+
+ if (result.Succeeded)
+ {
+ return CustomResponse(await _authenticateService.GenerateJWT(usuarioLogin.Email));
+ }
+
+ if (result.IsLockedOut)
+ {
+ AddErrorProcessing("User temporarily blocked for invalid attempts");
+ return CustomResponse();
+ }
+
+ AddErrorProcessing("Incorrect username or password");
+ return CustomResponse();
+ }
+
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/Base/MainController.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/Base/MainController.cs
new file mode 100644
index 0000000..5a43f42
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/Base/MainController.cs
@@ -0,0 +1,65 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace Browl.Service.AuthSecurity.API.Controllers.Base;
+
+///
+/// Abstract base controller class that provides common functionality for API controllers.
+///
+///
+/// This abstract class defines:
+/// - Errors: An IList property to hold a list of error strings.
+/// - CustomResponse(): A protected method that returns an ActionResult with custom error handling.
+/// - AddErrorProcessing(): A protected method to add an error string to the Errors collection.
+/// - ClearErrorsProcessing(): A protected method to clear the Errors collection.
+///
+/// Controllers that inherit from this base class can utilize these common members and methods for consistent error handling and responses.
+///
+[ApiController]
+public abstract class MainController : Controller
+{
+ // Collection to store error messages
+ protected IList Errors = new List();
+
+ ///
+ /// Custom response method to handle API responses
+ ///
+ /// Optional result object
+ /// Action result
+ protected ActionResult CustomResponse(object? result = null)
+ {
+ // Check if the model state is valid and there are no errors
+ if (ModelState.IsValid && Errors.Count == 0)
+ {
+ return Ok(result);
+ }
+
+ var errorDictionary = new Dictionary();
+
+ // Add model state errors to the dictionary
+ if (ModelState.ErrorCount > 0)
+ {
+ var modelErrors = ModelState.Values.SelectMany(v => v.Errors);
+ errorDictionary.Add("Messages", modelErrors.Select(e => e.ErrorMessage).ToArray());
+ }
+
+ // Add custom errors to the dictionary
+ if (Errors.Count > 0)
+ {
+ errorDictionary.Add("Messages", Errors.ToArray());
+ }
+
+ // Return a bad request response with the validation problem details
+ return BadRequest(new ValidationProblemDetails(errorDictionary));
+ }
+
+ ///
+ /// Add an error message to the collection
+ ///
+ /// Error message
+ protected void AddErrorProcessing(string error) => Errors.Add(error);
+
+ ///
+ /// Clear all error messages from the collection
+ ///
+ protected void ClearErrorsProcessing() => Errors.Clear();
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/UserController.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/UserController.cs
new file mode 100644
index 0000000..d382930
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Controllers/UserController.cs
@@ -0,0 +1,47 @@
+using Browl.Service.AuthSecurity.API.Resources;
+using Browl.Service.AuthSecurity.API.Services.Interfaces;
+
+using Microsoft.AspNetCore.Mvc;
+
+namespace Browl.Service.AuthSecurity.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class UserController : ControllerBase
+{
+ private readonly IUserService _userService;
+ public UserController(IUserService userService)
+ {
+ _userService = userService;
+ }
+
+ [HttpPost("register")]
+ public async Task UserRegistration(UserRegistrationResources userRegistration)
+ {
+ var result = await _userService.RegisterNewUserAsync(userRegistration);
+ if (result.IsUserRegistered)
+ {
+ return Ok(result.Message);
+ }
+
+ ModelState.AddModelError("Email", result.Message);
+ return BadRequest(ModelState);
+ }
+ [HttpGet("unique-user-email")]
+ public IActionResult CheckUniqueUserEmail(string email)
+ {
+ var result = _userService.CheckUserUniqueEmail(email);
+ return Ok(result);
+ }
+ [HttpPost("login")]
+ public async Task LoginAsync(LoginResource payload)
+ {
+ var result = await _userService.LoginAsync(payload);
+ if (result.IsLoginSuccess)
+ {
+ return Ok(result.TokeResponse);
+ }
+ ModelState.AddModelError("LoginError", "Invalid Credentials");
+ return BadRequest(ModelState);
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Data/BrowlAuthSecurityDbContext.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Data/BrowlAuthSecurityDbContext.cs
new file mode 100644
index 0000000..503d4b3
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Data/BrowlAuthSecurityDbContext.cs
@@ -0,0 +1,57 @@
+using Browl.Service.AuthSecurity.API.Entities;
+
+using Microsoft.AspNetCore.Identity;
+using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore;
+
+namespace Browl.Service.AuthSecurity.API.Data;
+
+public class BrowlAuthSecurityDbContext : IdentityDbContext
+{
+
+ public DbSet User { get; set; }
+
+ public BrowlAuthSecurityDbContext(DbContextOptions options)
+ : base(options)
+ {
+ }
+ protected override void OnModelCreating(ModelBuilder builder)
+ {
+ base.OnModelCreating(builder);
+ var unused14 = builder.HasDefaultSchema("Identity");
+ var unused13 = builder.Entity(entity =>
+ {
+ var unused12 = entity.ToTable(name: "User");
+ });
+
+ var unused11 = builder.Entity(entity =>
+ {
+ var unused10 = entity.ToTable(name: "Role");
+ });
+ var unused9 = builder.Entity>(entity =>
+ {
+ var unused8 = entity.ToTable("UserRoles");
+ });
+
+ var unused7 = builder.Entity>(entity =>
+ {
+ var unused6 = entity.ToTable("UserClaims");
+ });
+
+ var unused5 = builder.Entity>(entity =>
+ {
+ var unused4 = entity.ToTable("UserLogins");
+ });
+
+ var unused3 = builder.Entity>(entity =>
+ {
+ var unused2 = entity.ToTable("RoleClaims");
+
+ });
+
+ var unused1 = builder.Entity>(entity =>
+ {
+ var unused = entity.ToTable("UserTokens");
+ });
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Data/ContextSeed.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Data/ContextSeed.cs
new file mode 100644
index 0000000..15b5279
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Data/ContextSeed.cs
@@ -0,0 +1,45 @@
+using Browl.Service.AuthSecurity.API.Entities;
+
+using Microsoft.AspNetCore.Identity;
+
+namespace Browl.Service.AuthSecurity.API.Data;
+
+public static class ContextSeed
+{
+ public static async Task SeedRolesAsync(UserManager userManager, RoleManager roleManager)
+ {
+ //Seed Roles
+ _ = await roleManager.CreateAsync(new IdentityRole(Enums.Roles.SuperAdmin.ToString()));
+ _ = await roleManager.CreateAsync(new IdentityRole(Enums.Roles.Admin.ToString()));
+ _ = await roleManager.CreateAsync(new IdentityRole(Enums.Roles.Moderator.ToString()));
+ _ = await roleManager.CreateAsync(new IdentityRole(Enums.Roles.Basic.ToString()));
+ }
+ public static async Task SeedSuperAdminAsync(UserManager userManager, RoleManager roleManager)
+ {
+ //Seed Default User
+ var defaultUser = new User
+ {
+ UserName = "rondineleg",
+ Email = "superadmin@gmail.com",
+ FirstName = "Rondinele",
+ LastName = "Guimaraes",
+ UserNameChangeLimit = 10,
+ EmailConfirmed = true,
+ PhoneNumberConfirmed = true,
+
+ };
+ if (userManager.Users.All(u => u.Id != defaultUser.Id))
+ {
+ var user = await userManager.FindByEmailAsync(defaultUser.Email);
+ if (user == null)
+ {
+ var unused4 = await userManager.CreateAsync(defaultUser, "123Pa$$word.");
+ var unused3 = await userManager.AddToRoleAsync(defaultUser, Enums.Roles.Basic.ToString());
+ var unused2 = await userManager.AddToRoleAsync(defaultUser, Enums.Roles.Moderator.ToString());
+ var unused1 = await userManager.AddToRoleAsync(defaultUser, Enums.Roles.Admin.ToString());
+ var unused = await userManager.AddToRoleAsync(defaultUser, Enums.Roles.SuperAdmin.ToString());
+ }
+
+ }
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/AppSettings.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/AppSettings.cs
new file mode 100644
index 0000000..cfc562f
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/AppSettings.cs
@@ -0,0 +1,9 @@
+namespace Browl.Service.AuthSecurity.API.Entities;
+
+public class AppSettings
+{
+ public string Secret { get; set; }
+ public int ExpirationHours { get; set; }
+ public string Issuer { get; set; }
+ public string ValidOn { get; set; }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/ManageUserRoles.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/ManageUserRoles.cs
new file mode 100644
index 0000000..d8e2a1f
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/ManageUserRoles.cs
@@ -0,0 +1,8 @@
+namespace Browl.Service.AuthSecurity.API.Entities;
+
+public class ManageUserRoles
+{
+ public required string RoleId { get; set; }
+ public required string RoleName { get; set; }
+ public bool Selected { get; set; }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/User.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/User.cs
new file mode 100644
index 0000000..cf5f03a
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/User.cs
@@ -0,0 +1,17 @@
+using Microsoft.AspNetCore.Identity;
+
+namespace Browl.Service.AuthSecurity.API.Entities;
+public class User : IdentityUser
+{
+ public int Id { get; set; }
+
+ public string UserName { get; set; }
+ public string FirstName { get; set; }
+ public string LastName { get; set; }
+ public int UserNameChangeLimit { get; set; } = 5;
+ public byte[] ProfilePicture { get; set; }
+ public string Email { get; set; }
+ public string Password { get; set; }
+ public string PasswordConfirmation { get; set; }
+
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserClaim.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserClaim.cs
new file mode 100644
index 0000000..a21a716
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserClaim.cs
@@ -0,0 +1,7 @@
+namespace Browl.Service.AuthSecurity.API.Entities;
+
+public class UserClaim
+{
+ public required string Value { get; set; }
+ public required string Type { get; set; }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserLogin.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserLogin.cs
new file mode 100644
index 0000000..8485340
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserLogin.cs
@@ -0,0 +1,14 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Browl.Service.AuthSecurity.API.Entities;
+
+public class UserLogin
+{
+ [Required(ErrorMessage = "Field {0} is mandatory")]
+ [EmailAddress(ErrorMessage = "Field {0} is in an invalid format")]
+ public string Email { get; set; }
+
+ [Required(ErrorMessage = "Field {0} is mandatory")]
+ [StringLength(100, ErrorMessage = "Field {0} must be between {2} and {1} characters", MinimumLength = 6)]
+ public string Password { get; set; }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserRegister.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserRegister.cs
new file mode 100644
index 0000000..46fd9da
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserRegister.cs
@@ -0,0 +1,40 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Browl.Service.AuthSecurity.API.Entities;
+
+public class UserRegister
+{
+ public UserRegister(string userName, string firstName, string lastName, int userNameChangeLimit, byte[] profilePicture, string email, string password, string passwordConfirmation)
+ {
+ UserName = userName;
+ FirstName = firstName;
+ LastName = lastName;
+ UserNameChangeLimit = userNameChangeLimit;
+ ProfilePicture = profilePicture;
+ Email = email;
+ Password = password;
+ PasswordConfirmation = passwordConfirmation;
+ }
+
+ [Required(ErrorMessage = "Field {0} is mandatory")]
+ public string UserName { get; set; }
+
+ [Required(ErrorMessage = "Field {0} is mandatory")]
+ public string FirstName { get; set; }
+ [Required(ErrorMessage = "Field {0} is mandatory")]
+ public string LastName { get; set; }
+ public int UserNameChangeLimit { get; set; } = 5;
+ [Required(ErrorMessage = "Field {0} is mandatory")]
+ public byte[] ProfilePicture { get; set; }
+
+ [Required(ErrorMessage = "Field {0} is mandatory")]
+ [EmailAddress(ErrorMessage = "Field {0} is in an invalid format")]
+ public string Email { get; set; }
+
+ [Required(ErrorMessage = "Field {0} is mandatory")]
+ [StringLength(100, ErrorMessage = "Field {0} must be between {2} and {1} characters", MinimumLength = 6)]
+ public string Password { get; set; }
+
+ [Compare("Password", ErrorMessage = "Passwords don't match.")]
+ public string PasswordConfirmation { get; set; }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserResponse.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserResponse.cs
new file mode 100644
index 0000000..89b0a63
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserResponse.cs
@@ -0,0 +1,8 @@
+namespace Browl.Service.AuthSecurity.API.Entities;
+public class UserResponse
+{
+ public required string AccessToken { get; set; }
+ public double ExpiresIn { get; set; }
+ public required UserToken UserToken { get; set; }
+}
+
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserRoles.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserRoles.cs
new file mode 100644
index 0000000..7de4f76
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserRoles.cs
@@ -0,0 +1,11 @@
+namespace Browl.Service.AuthSecurity.API.Entities;
+
+public class UserRoles
+{
+ public required string UserId { get; set; }
+ public required string FirstName { get; set; }
+ public required string LastName { get; set; }
+ public required string UserName { get; set; }
+ public required string Email { get; set; }
+ public required IEnumerable Roles { get; set; }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserToken.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserToken.cs
new file mode 100644
index 0000000..1fda473
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Entities/UserToken.cs
@@ -0,0 +1,7 @@
+namespace Browl.Service.AuthSecurity.API.Entities;
+public class UserToken
+{
+ public string Id { get; set; }
+ public string Email { get; set; }
+ public IEnumerable UserClaims { get; set; }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Enums/Roles.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Enums/Roles.cs
new file mode 100644
index 0000000..80b1c5e
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Enums/Roles.cs
@@ -0,0 +1,9 @@
+namespace Browl.Service.AuthSecurity.API.Enums;
+
+public enum Roles
+{
+ SuperAdmin,
+ Admin,
+ Moderator,
+ Basic
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230916004956_InicialCreate.Designer.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230916004956_InicialCreate.Designer.cs
new file mode 100644
index 0000000..e2b6fad
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230916004956_InicialCreate.Designer.cs
@@ -0,0 +1,309 @@
+//
+using System;
+using Browl.Service.AuthSecurity.API.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Browl.Service.AuthSecurity.API.Migrations
+{
+ [DbContext(typeof(BrowlAuthSecurityDbContext))]
+ [Migration("20230916004956_InicialCreate")]
+ partial class InicialCreate
+ {
+ ///
+ protected override void BuildTargetModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasDefaultSchema("Identity")
+ .HasAnnotation("ProductVersion", "7.0.10")
+ .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+ SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+ modelBuilder.Entity("Browl.Service.AuthSecurity.Domain.Entities.User", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("AccessFailedCount")
+ .HasColumnType("int");
+
+ b.Property("ConcurrencyStamp")
+ .IsConcurrencyToken()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("Email")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("EmailConfirmed")
+ .HasColumnType("bit");
+
+ b.Property("FirstName")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("LastName")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("LockoutEnabled")
+ .HasColumnType("bit");
+
+ b.Property("LockoutEnd")
+ .HasColumnType("datetimeoffset");
+
+ b.Property("NormalizedEmail")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("NormalizedUserName")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("Password")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PasswordConfirmation")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PasswordHash")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PhoneNumber")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PhoneNumberConfirmed")
+ .HasColumnType("bit");
+
+ b.Property("ProfilePicture")
+ .IsRequired()
+ .HasColumnType("varbinary(max)");
+
+ b.Property("SecurityStamp")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("TwoFactorEnabled")
+ .HasColumnType("bit");
+
+ b.Property("UserName")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("UserNameChangeLimit")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedEmail")
+ .HasDatabaseName("EmailIndex");
+
+ b.HasIndex("NormalizedUserName")
+ .IsUnique()
+ .HasDatabaseName("UserNameIndex")
+ .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+ b.ToTable("User", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("ConcurrencyStamp")
+ .IsConcurrencyToken()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("Name")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("NormalizedName")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedName")
+ .IsUnique()
+ .HasDatabaseName("RoleNameIndex")
+ .HasFilter("[NormalizedName] IS NOT NULL");
+
+ b.ToTable("Role", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("ClaimValue")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("RoleId")
+ .IsRequired()
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("RoleId");
+
+ b.ToTable("RoleClaims", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("ClaimValue")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("UserId");
+
+ b.ToTable("UserClaims", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
+ {
+ b.Property("LoginProvider")
+ .HasMaxLength(128)
+ .HasColumnType("nvarchar(128)");
+
+ b.Property("ProviderKey")
+ .HasMaxLength(128)
+ .HasColumnType("nvarchar(128)");
+
+ b.Property("ProviderDisplayName")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("LoginProvider", "ProviderKey");
+
+ b.HasIndex("UserId");
+
+ b.ToTable("UserLogins", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
+ {
+ b.Property("UserId")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("RoleId")
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("UserId", "RoleId");
+
+ b.HasIndex("RoleId");
+
+ b.ToTable("UserRoles", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
+ {
+ b.Property("UserId")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("LoginProvider")
+ .HasMaxLength(128)
+ .HasColumnType("nvarchar(128)");
+
+ b.Property("Name")
+ .HasMaxLength(128)
+ .HasColumnType("nvarchar(128)");
+
+ b.Property("Value")
+ .HasColumnType("nvarchar(max)");
+
+ b.HasKey("UserId", "LoginProvider", "Name");
+
+ b.ToTable("UserTokens", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
+ {
+ b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+ .WithMany()
+ .HasForeignKey("RoleId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
+ {
+ b.HasOne("Browl.Service.AuthSecurity.Domain.Entities.User", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
+ {
+ b.HasOne("Browl.Service.AuthSecurity.Domain.Entities.User", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
+ {
+ b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+ .WithMany()
+ .HasForeignKey("RoleId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+
+ b.HasOne("Browl.Service.AuthSecurity.Domain.Entities.User", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
+ {
+ b.HasOne("Browl.Service.AuthSecurity.Domain.Entities.User", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+#pragma warning restore 612, 618
+ }
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230916004956_InicialCreate.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230916004956_InicialCreate.cs
new file mode 100644
index 0000000..935a0fa
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230916004956_InicialCreate.cs
@@ -0,0 +1,252 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Browl.Service.AuthSecurity.API.Migrations;
+
+///
+public partial class InicialCreate : Migration
+{
+ ///
+ protected override void Up(MigrationBuilder migrationBuilder)
+ {
+ var unused27 = migrationBuilder.EnsureSchema(
+ name: "Identity");
+
+ var unused26 = migrationBuilder.CreateTable(
+ name: "Role",
+ schema: "Identity",
+ columns: table => new
+ {
+ Id = table.Column(type: "nvarchar(450)", nullable: false),
+ Name = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true),
+ NormalizedName = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true),
+ ConcurrencyStamp = table.Column(type: "nvarchar(max)", nullable: true)
+ },
+ constraints: table =>
+ {
+ var unused25 = table.PrimaryKey("PK_Role", x => x.Id);
+ });
+
+ var unused24 = migrationBuilder.CreateTable(
+ name: "User",
+ schema: "Identity",
+ columns: table => new
+ {
+ Id = table.Column(type: "nvarchar(450)", nullable: false),
+ UserName = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: false),
+ FirstName = table.Column(type: "nvarchar(max)", nullable: false),
+ LastName = table.Column(type: "nvarchar(max)", nullable: false),
+ UserNameChangeLimit = table.Column(type: "int", nullable: false),
+ ProfilePicture = table.Column(type: "varbinary(max)", nullable: false),
+ Email = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: false),
+ Password = table.Column(type: "nvarchar(max)", nullable: false),
+ PasswordConfirmation = table.Column(type: "nvarchar(max)", nullable: false),
+ NormalizedUserName = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true),
+ NormalizedEmail = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true),
+ EmailConfirmed = table.Column(type: "bit", nullable: false),
+ PasswordHash = table.Column(type: "nvarchar(max)", nullable: true),
+ SecurityStamp = table.Column(type: "nvarchar(max)", nullable: true),
+ ConcurrencyStamp = table.Column(type: "nvarchar(max)", nullable: true),
+ PhoneNumber = table.Column(type: "nvarchar(max)", nullable: true),
+ PhoneNumberConfirmed = table.Column(type: "bit", nullable: false),
+ TwoFactorEnabled = table.Column(type: "bit", nullable: false),
+ LockoutEnd = table.Column(type: "datetimeoffset", nullable: true),
+ LockoutEnabled = table.Column(type: "bit", nullable: false),
+ AccessFailedCount = table.Column(type: "int", nullable: false)
+ },
+ constraints: table =>
+ {
+ var unused23 = table.PrimaryKey("PK_User", x => x.Id);
+ });
+
+ var unused22 = migrationBuilder.CreateTable(
+ name: "RoleClaims",
+ schema: "Identity",
+ columns: table => new
+ {
+ Id = table.Column(type: "int", nullable: false)
+ .Annotation("SqlServer:Identity", "1, 1"),
+ RoleId = table.Column(type: "nvarchar(450)", nullable: false),
+ ClaimType = table.Column(type: "nvarchar(max)", nullable: true),
+ ClaimValue = table.Column(type: "nvarchar(max)", nullable: true)
+ },
+ constraints: table =>
+ {
+ var unused21 = table.PrimaryKey("PK_RoleClaims", x => x.Id);
+ var unused20 = table.ForeignKey(
+ name: "FK_RoleClaims_Role_RoleId",
+ column: x => x.RoleId,
+ principalSchema: "Identity",
+ principalTable: "Role",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ var unused19 = migrationBuilder.CreateTable(
+ name: "UserClaims",
+ schema: "Identity",
+ columns: table => new
+ {
+ Id = table.Column(type: "int", nullable: false)
+ .Annotation("SqlServer:Identity", "1, 1"),
+ UserId = table.Column(type: "nvarchar(450)", nullable: false),
+ ClaimType = table.Column(type: "nvarchar(max)", nullable: true),
+ ClaimValue = table.Column(type: "nvarchar(max)", nullable: true)
+ },
+ constraints: table =>
+ {
+ var unused18 = table.PrimaryKey("PK_UserClaims", x => x.Id);
+ var unused17 = table.ForeignKey(
+ name: "FK_UserClaims_User_UserId",
+ column: x => x.UserId,
+ principalSchema: "Identity",
+ principalTable: "User",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ var unused16 = migrationBuilder.CreateTable(
+ name: "UserLogins",
+ schema: "Identity",
+ columns: table => new
+ {
+ LoginProvider = table.Column(type: "nvarchar(128)", maxLength: 128, nullable: false),
+ ProviderKey = table.Column(type: "nvarchar(128)", maxLength: 128, nullable: false),
+ ProviderDisplayName = table.Column(type: "nvarchar(max)", nullable: true),
+ UserId = table.Column(type: "nvarchar(450)", nullable: false)
+ },
+ constraints: table =>
+ {
+ var unused15 = table.PrimaryKey("PK_UserLogins", x => new { x.LoginProvider, x.ProviderKey });
+ var unused14 = table.ForeignKey(
+ name: "FK_UserLogins_User_UserId",
+ column: x => x.UserId,
+ principalSchema: "Identity",
+ principalTable: "User",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ var unused13 = migrationBuilder.CreateTable(
+ name: "UserRoles",
+ schema: "Identity",
+ columns: table => new
+ {
+ UserId = table.Column(type: "nvarchar(450)", nullable: false),
+ RoleId = table.Column(type: "nvarchar(450)", nullable: false)
+ },
+ constraints: table =>
+ {
+ var unused12 = table.PrimaryKey("PK_UserRoles", x => new { x.UserId, x.RoleId });
+ var unused11 = table.ForeignKey(
+ name: "FK_UserRoles_Role_RoleId",
+ column: x => x.RoleId,
+ principalSchema: "Identity",
+ principalTable: "Role",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ var unused10 = table.ForeignKey(
+ name: "FK_UserRoles_User_UserId",
+ column: x => x.UserId,
+ principalSchema: "Identity",
+ principalTable: "User",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ var unused9 = migrationBuilder.CreateTable(
+ name: "UserTokens",
+ schema: "Identity",
+ columns: table => new
+ {
+ UserId = table.Column(type: "nvarchar(450)", nullable: false),
+ LoginProvider = table.Column(type: "nvarchar(128)", maxLength: 128, nullable: false),
+ Name = table.Column(type: "nvarchar(128)", maxLength: 128, nullable: false),
+ Value = table.Column(type: "nvarchar(max)", nullable: true)
+ },
+ constraints: table =>
+ {
+ var unused8 = table.PrimaryKey("PK_UserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
+ var unused7 = table.ForeignKey(
+ name: "FK_UserTokens_User_UserId",
+ column: x => x.UserId,
+ principalSchema: "Identity",
+ principalTable: "User",
+ principalColumn: "Id",
+ onDelete: ReferentialAction.Cascade);
+ });
+
+ var unused6 = migrationBuilder.CreateIndex(
+ name: "RoleNameIndex",
+ schema: "Identity",
+ table: "Role",
+ column: "NormalizedName",
+ unique: true,
+ filter: "[NormalizedName] IS NOT NULL");
+
+ var unused5 = migrationBuilder.CreateIndex(
+ name: "IX_RoleClaims_RoleId",
+ schema: "Identity",
+ table: "RoleClaims",
+ column: "RoleId");
+
+ var unused4 = migrationBuilder.CreateIndex(
+ name: "EmailIndex",
+ schema: "Identity",
+ table: "User",
+ column: "NormalizedEmail");
+
+ var unused3 = migrationBuilder.CreateIndex(
+ name: "UserNameIndex",
+ schema: "Identity",
+ table: "User",
+ column: "NormalizedUserName",
+ unique: true,
+ filter: "[NormalizedUserName] IS NOT NULL");
+
+ var unused2 = migrationBuilder.CreateIndex(
+ name: "IX_UserClaims_UserId",
+ schema: "Identity",
+ table: "UserClaims",
+ column: "UserId");
+
+ var unused1 = migrationBuilder.CreateIndex(
+ name: "IX_UserLogins_UserId",
+ schema: "Identity",
+ table: "UserLogins",
+ column: "UserId");
+
+ var unused = migrationBuilder.CreateIndex(
+ name: "IX_UserRoles_RoleId",
+ schema: "Identity",
+ table: "UserRoles",
+ column: "RoleId");
+ }
+
+ ///
+ protected override void Down(MigrationBuilder migrationBuilder)
+ {
+ _ = migrationBuilder.DropTable(
+ name: "RoleClaims",
+ schema: "Identity");
+ _ = migrationBuilder.DropTable(
+ name: "UserClaims",
+ schema: "Identity");
+ _ = migrationBuilder.DropTable(
+ name: "UserLogins",
+ schema: "Identity");
+ _ = migrationBuilder.DropTable(
+ name: "UserRoles",
+ schema: "Identity");
+ _ = migrationBuilder.DropTable(
+ name: "UserTokens",
+ schema: "Identity");
+ _ = migrationBuilder.DropTable(
+ name: "Role",
+ schema: "Identity");
+ _ = migrationBuilder.DropTable(
+ name: "User",
+ schema: "Identity");
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230917173751_AddEntitieUser.Designer.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230917173751_AddEntitieUser.Designer.cs
new file mode 100644
index 0000000..880410a
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230917173751_AddEntitieUser.Designer.cs
@@ -0,0 +1,309 @@
+//
+using System;
+using Browl.Service.AuthSecurity.API.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Browl.Service.AuthSecurity.API.Migrations
+{
+ [DbContext(typeof(BrowlAuthSecurityDbContext))]
+ [Migration("20230917173751_AddEntitieUser")]
+ partial class AddEntitieUser
+ {
+ ///
+ protected override void BuildTargetModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasDefaultSchema("Identity")
+ .HasAnnotation("ProductVersion", "7.0.10")
+ .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+ SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+ modelBuilder.Entity("Browl.Service.AuthSecurity.API.Entities.User", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("AccessFailedCount")
+ .HasColumnType("int");
+
+ b.Property("ConcurrencyStamp")
+ .IsConcurrencyToken()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("Email")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("EmailConfirmed")
+ .HasColumnType("bit");
+
+ b.Property("FirstName")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("LastName")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("LockoutEnabled")
+ .HasColumnType("bit");
+
+ b.Property("LockoutEnd")
+ .HasColumnType("datetimeoffset");
+
+ b.Property("NormalizedEmail")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("NormalizedUserName")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("Password")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PasswordConfirmation")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PasswordHash")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PhoneNumber")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PhoneNumberConfirmed")
+ .HasColumnType("bit");
+
+ b.Property("ProfilePicture")
+ .IsRequired()
+ .HasColumnType("varbinary(max)");
+
+ b.Property("SecurityStamp")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("TwoFactorEnabled")
+ .HasColumnType("bit");
+
+ b.Property("UserName")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("UserNameChangeLimit")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedEmail")
+ .HasDatabaseName("EmailIndex");
+
+ b.HasIndex("NormalizedUserName")
+ .IsUnique()
+ .HasDatabaseName("UserNameIndex")
+ .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+ b.ToTable("User", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("ConcurrencyStamp")
+ .IsConcurrencyToken()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("Name")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("NormalizedName")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedName")
+ .IsUnique()
+ .HasDatabaseName("RoleNameIndex")
+ .HasFilter("[NormalizedName] IS NOT NULL");
+
+ b.ToTable("Role", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("ClaimValue")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("RoleId")
+ .IsRequired()
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("RoleId");
+
+ b.ToTable("RoleClaims", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("ClaimValue")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("UserId");
+
+ b.ToTable("UserClaims", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
+ {
+ b.Property("LoginProvider")
+ .HasMaxLength(128)
+ .HasColumnType("nvarchar(128)");
+
+ b.Property("ProviderKey")
+ .HasMaxLength(128)
+ .HasColumnType("nvarchar(128)");
+
+ b.Property("ProviderDisplayName")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("LoginProvider", "ProviderKey");
+
+ b.HasIndex("UserId");
+
+ b.ToTable("UserLogins", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
+ {
+ b.Property("UserId")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("RoleId")
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("UserId", "RoleId");
+
+ b.HasIndex("RoleId");
+
+ b.ToTable("UserRoles", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
+ {
+ b.Property("UserId")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("LoginProvider")
+ .HasMaxLength(128)
+ .HasColumnType("nvarchar(128)");
+
+ b.Property("Name")
+ .HasMaxLength(128)
+ .HasColumnType("nvarchar(128)");
+
+ b.Property("Value")
+ .HasColumnType("nvarchar(max)");
+
+ b.HasKey("UserId", "LoginProvider", "Name");
+
+ b.ToTable("UserTokens", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
+ {
+ b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+ .WithMany()
+ .HasForeignKey("RoleId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
+ {
+ b.HasOne("Browl.Service.AuthSecurity.API.Entities.User", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
+ {
+ b.HasOne("Browl.Service.AuthSecurity.API.Entities.User", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
+ {
+ b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+ .WithMany()
+ .HasForeignKey("RoleId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+
+ b.HasOne("Browl.Service.AuthSecurity.API.Entities.User", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
+ {
+ b.HasOne("Browl.Service.AuthSecurity.API.Entities.User", null)
+ .WithMany()
+ .HasForeignKey("UserId")
+ .OnDelete(DeleteBehavior.Cascade)
+ .IsRequired();
+ });
+#pragma warning restore 612, 618
+ }
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230917173751_AddEntitieUser.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230917173751_AddEntitieUser.cs
new file mode 100644
index 0000000..33a5dda
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/20230917173751_AddEntitieUser.cs
@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Browl.Service.AuthSecurity.API.Migrations
+{
+ ///
+ public partial class AddEntitieUser : Migration
+ {
+ ///
+ protected override void Up(MigrationBuilder migrationBuilder)
+ {
+
+ }
+
+ ///
+ protected override void Down(MigrationBuilder migrationBuilder)
+ {
+
+ }
+ }
+}
diff --git a/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/BrowlAuthSecurityDbContextModelSnapshot.cs b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/BrowlAuthSecurityDbContextModelSnapshot.cs
new file mode 100644
index 0000000..02fbdcc
--- /dev/null
+++ b/src/Services/Browl.Service.AuthSecurity/Browl.Service.AuthSecurity.API/Migrations/BrowlAuthSecurityDbContextModelSnapshot.cs
@@ -0,0 +1,306 @@
+//
+using System;
+using Browl.Service.AuthSecurity.API.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Browl.Service.AuthSecurity.API.Migrations
+{
+ [DbContext(typeof(BrowlAuthSecurityDbContext))]
+ partial class BrowlAuthSecurityDbContextModelSnapshot : ModelSnapshot
+ {
+ protected override void BuildModel(ModelBuilder modelBuilder)
+ {
+#pragma warning disable 612, 618
+ modelBuilder
+ .HasDefaultSchema("Identity")
+ .HasAnnotation("ProductVersion", "7.0.10")
+ .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+ SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+ modelBuilder.Entity("Browl.Service.AuthSecurity.API.Entities.User", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("AccessFailedCount")
+ .HasColumnType("int");
+
+ b.Property("ConcurrencyStamp")
+ .IsConcurrencyToken()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("Email")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("EmailConfirmed")
+ .HasColumnType("bit");
+
+ b.Property("FirstName")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("LastName")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("LockoutEnabled")
+ .HasColumnType("bit");
+
+ b.Property("LockoutEnd")
+ .HasColumnType("datetimeoffset");
+
+ b.Property("NormalizedEmail")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("NormalizedUserName")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("Password")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PasswordConfirmation")
+ .IsRequired()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PasswordHash")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PhoneNumber")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("PhoneNumberConfirmed")
+ .HasColumnType("bit");
+
+ b.Property("ProfilePicture")
+ .IsRequired()
+ .HasColumnType("varbinary(max)");
+
+ b.Property("SecurityStamp")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("TwoFactorEnabled")
+ .HasColumnType("bit");
+
+ b.Property("UserName")
+ .IsRequired()
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("UserNameChangeLimit")
+ .HasColumnType("int");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedEmail")
+ .HasDatabaseName("EmailIndex");
+
+ b.HasIndex("NormalizedUserName")
+ .IsUnique()
+ .HasDatabaseName("UserNameIndex")
+ .HasFilter("[NormalizedUserName] IS NOT NULL");
+
+ b.ToTable("User", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+ {
+ b.Property("Id")
+ .HasColumnType("nvarchar(450)");
+
+ b.Property("ConcurrencyStamp")
+ .IsConcurrencyToken()
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("Name")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.Property("NormalizedName")
+ .HasMaxLength(256)
+ .HasColumnType("nvarchar(256)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("NormalizedName")
+ .IsUnique()
+ .HasDatabaseName("RoleNameIndex")
+ .HasFilter("[NormalizedName] IS NOT NULL");
+
+ b.ToTable("Role", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("ClaimValue")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("RoleId")
+ .IsRequired()
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("RoleId");
+
+ b.ToTable("RoleClaims", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
+ {
+ b.Property("Id")
+ .ValueGeneratedOnAdd()
+ .HasColumnType("int");
+
+ SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id"));
+
+ b.Property("ClaimType")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("ClaimValue")
+ .HasColumnType("nvarchar(max)");
+
+ b.Property("UserId")
+ .IsRequired()
+ .HasColumnType("nvarchar(450)");
+
+ b.HasKey("Id");
+
+ b.HasIndex("UserId");
+
+ b.ToTable("UserClaims", "Identity");
+ });
+
+ modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin