public IdentityService(UserManager <ApplicationUser> userManager,
RoleManager <IdentityRole <int> > roleManager,
IOptions <JWTSettings> jwtSettings,
IDateTimeService dateTimeService,
SignInManager <ApplicationUser> signInManager, IMailService mailService)
{
_userManager = userManager;
_roleManager = roleManager;
_jwtSettings = jwtSettings.Value;
_dateTimeService = dateTimeService;
_signInManager = signInManager;
_mailService = mailService;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
var jwtSettings = new JWTSettings();
var identityUrl = Configuration.GetValue <string>("IdentityUrl");
var callbackUrl = Configuration.GetValue <string>("CallBackUrl");
var sessionCookieLifetime = Configuration.GetValue("SessionCookieLifetime", 60);
services.Configure <FacebookAuthSettings>(Configuration.GetSection("JWTSettings"));
Configuration.GetSection("JWTSettings").Bind(jwtSettings);
var facebookAuthSettings = new FacebookAuthSettings();
services.Configure <FacebookAuthSettings>(Configuration.GetSection("FacebookAuthSettings"));
Configuration.GetSection("FacebookAuthSettings").Bind(facebookAuthSettings);
services.AddSingleton(facebookAuthSettings);
services.AddSingleton(jwtSettings);
services.AddSingleton <IFacebookInterface, FacebookRepo>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped <IUserInterfaces, UserService>();
services.AddScoped <IIdentityService, IdentityService>();
services.AddRouting();
services.AddControllers();
services.AddRazorPages();
services.AddControllersWithViews().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore);
services.AddSession(option => option.IdleTimeout = TimeSpan.FromSeconds(60 * 90));
services.AddAuthentication(option =>
{
option.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
option.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
option.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(x => {
x.SaveToken = true;
x.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(jwtSettings.Secret)),
ValidateIssuer = false,
ValidateAudience = false,
RequireExpirationTime = false,
ValidateLifetime = false,
};
}).AddCookie(setup => setup.ExpireTimeSpan = TimeSpan.FromMinutes(sessionCookieLifetime));
//services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
// .AddEntityFrameworkStores<ApplicationDbContext>();
services.AddHttpClient();
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
var jwtSettings = new JWTSettings();
configuration.Bind(nameof(JWTSettings), jwtSettings);
services.AddSingleton(jwtSettings);
services.AddScoped <IIdentityService, IdentityService>();
services
.AddMvc(options =>
{
options.EnableEndpointRouting = false;
options.Filters.Add <ValidationFilter>();
})
.AddFluentValidation(mvcConfiguration => mvcConfiguration.RegisterValidatorsFromAssemblyContaining <Startup>());
var tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(jwtSettings.Secret)),
ValidateIssuer = false,
ValidateAudience = false,
RequireExpirationTime = false,
ValidateLifetime = true
};
services.AddSingleton(tokenValidationParameters);
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.SaveToken = true;
x.TokenValidationParameters = tokenValidationParameters;
});
services.AddAuthorization(options => {
options.AddPolicy("MustWorkForABMakers", configurePolicy: policy => {
policy.AddRequirements(new WorksForCompanyRequirements("abmakers.com"));
});
});
services.AddSingleton <IAuthorizationHandler, WorksForComapnyHandler>();
}
public IdentityService(
UserManager <IdentityUser> userManager,
JWTSettings jWTSettings,
TokenValidationParameters tokenValidationParameters,
RoleManager <IdentityRole> roleManager,
DataContext dataContext)
{
;
_userManager = userManager;
_jWTSettings = jWTSettings;
_tokenValidationParameters = tokenValidationParameters;
_dataContext = dataContext;
_roleManager = roleManager;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//var cacheSettings = Configuration.GetSection("CacheSettings").Get<CacheSettings>();
//var cacheValues = Env.IsDevelopment() ? cacheSettings.Local : cacheSettings.Remote;
//// Add framework services.
//services.AddMvc(options =>
//{
// options.Filters.Add(typeof(ApiExceptionFilter));
// options.CacheProfiles.Add("DynamicContent", new CacheProfile()
// {
// Duration = cacheValues.DynamicContent
// });
// options.CacheProfiles.Add("StaticContent", new CacheProfile()
// {
// Duration = cacheValues.StaticContent
// });
//});
//services.AddScoped<ApiExceptionFilter>();
//services.AddCors(o => o.AddPolicy("CorsPolicy", builder =>
//{
// builder.AllowAnyOrigin()
// .AllowAnyMethod()
// .AllowAnyHeader();
//}));
services.AddMvc(options => {
options.Filters.Add(typeof(ApiExceptionFilter));
});
var jwtSettings = new JWTSettings();
Configuration.Bind("JWTSettings", jwtSettings);
var signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(jwtSettings.SecretKey));
var tokenValidationParameters = GetTokenValidationParameters(signingKey, jwtSettings);
services.AddAuthentication(options =>
{
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
options.Audience = jwtSettings.Audience;
options.ClaimsIssuer = jwtSettings.Issuer;
options.TokenValidationParameters = tokenValidationParameters;
options.SaveToken = true;
});
services.ConfigurePlayTogetherServices(Configuration, Env);
}
public AuthenticateController(IOptions <JWTSettings> jwtOptions,
SignInManager <IdentityUser> signInManager,
IOptions <Settings> options,
UserService userService,
PersonService personService,
JwtService jwtService)
{
_signInManager = signInManager;
_userService = userService;
_personService = personService;
_jwtService = jwtService;
_jwtOptions = jwtOptions.Value;
_settings = options.Value;
}
public AccountService(UserManager <ApplicationUser> userManager,
RoleManager <IdentityRole> roleManager,
IOptions <JWTSettings> jwtSettings,
IDateTimeService dateTimeService,
SignInManager <ApplicationUser> signInManager,
IEmailService emailService)
{
_userManager = userManager;
_roleManager = roleManager;
_jwtSettings = jwtSettings.Value;
_dateTimeService = dateTimeService;
_signInManager = signInManager;
this._emailService = emailService;
}
private UsersController CreateController(DbContext context)
{
JWTSettings settings = new JWTSettings()
{
SecretKey = "thisisasecretkeyanddontsharewithanyone"
};
IOptions <JWTSettings> jwtSettings = Options.Create(settings);
return(new UsersController(new DeleteValidatorBase <User>(context),
new UserCommitValidator(context), context, jwtSettings)
{
ControllerContext = ControllerContext
});
}
public IActionResult RefreshToken([FromBody] RefreshTokenModel token)
{
try
{
JWTUserModel user = JWTSettings.GetNewAccessToken(token);
if (user == null)
{
return(Unauthorized());
}
return(Ok(user));
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status401Unauthorized));
}
}
public AccountController(
ApplicationDbContext context,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IEmailSender emailSender,
IHostingEnvironment environment,
IOptions <JWTSettings> optionsAccessor)
{
_context = context;
_userManager = userManager;
_signInManager = signInManager;
_emailSender = emailSender;
_environment = environment;
_options = optionsAccessor.Value;
_uploadPath = Path.Combine(_environment.WebRootPath, "images\\upload\\users\\");
}
public IdentityService(UserManager <ApplicationUser> userManager,
IOptions <JWTSettings> jwtSettings,
SignInManager <ApplicationUser> signInManager,
IUserRepository userRepository,
ILogger <IdentityService> logger,
IOptions <AppSettings> appSettings,
IMailService mailService)
{
_userManager = userManager;
_jwtSettings = jwtSettings.Value;
_signInManager = signInManager;
_mailService = mailService;
_userRepository = userRepository;
_appSettings = appSettings.Value;
_logger = logger;
}
//private readonly IGender gender;
public IdentityService(UserManager <ApplicationUser> userManager,
RoleManager <IdentityRole> roleManager,
IOptions <JWTSettings> jwtSettings,
IDateTimeService dateTimeService,
IApplicationDbContext applicationDbContext,
SignInManager <ApplicationUser> signInManager, IMailService mailService, IAuthenticatedUserService authenticatedUserService)
{
_userManager = userManager;
_roleManager = roleManager;
_jwtSettings = jwtSettings.Value;
_dateTimeService = dateTimeService;
_signInManager = signInManager;
_mailService = mailService;
_authenticatedUserService = authenticatedUserService;
_applicationDbContext = applicationDbContext;
}
private JwtSecurityToken BuildToken(JWTSettings jwtSettings, ClaimsIdentity identity)
{
SymmetricSecurityKey key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSettings.SecretKey));
SigningCredentials creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
DateTime utcNow = DateTime.UtcNow;
JwtSecurityToken jwtSecurityToken = new JwtSecurityToken(
jwtSettings.Issuer,
jwtSettings.Audience,
identity.Claims,
utcNow,
utcNow.AddMinutes(jwtSettings.Lifetime),
creds);
return(jwtSecurityToken);
}
public AuthController(
IHostingEnvironment env,
UserManager <ApplicationUser> userManager,
SignInManager <ApplicationUser> signInManager,
IOptions <JWTSettings> optionsAccessor,
IEmailSender emailSender,
ISmsSender smsSender,
ILoggerFactory loggerFactory) : base(env)
{
_userManager = userManager;
_signInManager = signInManager;
_options = optionsAccessor.Value;
_emailSender = emailSender;
_smsSender = smsSender;
_logger = loggerFactory.CreateLogger <AuthController>();
}
/// <summary>
/// Configures DI
/// </summary>
/// <param name="services">Service collection</param>
public void ConfigureServices(IServiceCollection services)
{
//EF Core
services.AddControllers();
services.AddDbContext <SpacedRepetionSystemDBContext>(
options => options.UseSqlServer(Configuration.GetConnectionString("Default")), ServiceLifetime.Transient);
services.AddTransient <DbContext, SpacedRepetionSystemDBContext>();
services.AddMvc(option => option.EnableEndpointRouting = false)
.SetCompatibilityVersion(CompatibilityVersion.Latest)
.AddNewtonsoftJson(opt => opt.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore);
//Authentication
IConfigurationSection jwtSection = Configuration.GetSection("JWTSettings");
services.Configure <JWTSettings>(jwtSection);
JWTSettings jwtSettings = jwtSection.Get <JWTSettings>();
byte[] key = Encoding.ASCII.GetBytes(jwtSettings.SecretKey);
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = true;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false,
ClockSkew = TimeSpan.Zero
};
});
//Validators
services.AddScoped(typeof(CommitValidatorBase <>), typeof(CommitValidatorBase <>));
services.AddScoped(typeof(DeleteValidatorBase <>), typeof(DeleteValidatorBase <>));
services.AddValidator <CommitValidatorBase <Card>, CardCommitValidator>();
services.AddValidator <CommitValidatorBase <Deck>, DeckCommitValidator>();
services.AddValidator <CommitValidatorBase <User>, UserCommitValidator>();
services.AddValidator <CommitValidatorBase <CardTemplate>, CardTemplateCommitValidator>();
services.AddValidator <DeleteValidatorBase <CardTemplate>, CardTemplateDeleteValidator>();
}
private static string GenerateAccessToken(long userId, JWTSettings jwtSettings)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(jwtSettings.SecretKey);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new []
{
new Claim(ClaimTypes.Name, Convert.ToString(userId))
}),
Expires = DateTime.UtcNow.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));
}
private static string GetToken(JWTSettings _options, Dictionary <string, object> payload)
{
var secret = _options.SecretKey;
//byte[] key = Convert.FromBase64String(secret);
payload.Add("iss", _options.Issuer);
payload.Add("aud", _options.Audience);
payload.Add("nbf", ConvertToUnixTimestamp(DateTime.Now));
payload.Add("iat", ConvertToUnixTimestamp(DateTime.Now));
payload.Add("exp", ConvertToUnixTimestamp(DateTime.Now.AddDays(1)));
IJwtAlgorithm algorithm = new HMACSHA256Algorithm();
IJsonSerializer serializer = new JsonNetSerializer();
IBase64UrlEncoder urlEncoder = new JwtBase64UrlEncoder();
IJwtEncoder encoder = new JwtEncoder(algorithm, serializer, urlEncoder);
return(encoder.Encode(payload, secret));
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
var jwtSettings = new JWTSettings();
configuration.Bind(key: nameof(jwtSettings), jwtSettings);
TokenValidationParameters tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(jwtSettings.Secret)),
ValidateIssuer = false,
ValidateAudience = false,
RequireExpirationTime = false,
ValidateLifetime = true,
ValidateActor = true
};
services.AddSingleton(tokenValidationParameters);
services.AddSingleton(jwtSettings);
services.AddScoped <IIdentityService, IdentityService>();
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.SaveToken = true;
x.TokenValidationParameters = tokenValidationParameters;
});
services.AddAuthorization();
services.AddCors(options =>
{
options.AddPolicy("p",
builder =>
{
builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
});
});
services.AddControllers();
}
private async Task <string> GenerateToken(User user, JWTSettings jwtSettings)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(jwtSettings.Key);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[] {
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Name, user.Email)
}),
Issuer = "",
Expires = DateTime.Now.AddDays(jwtSettings.ExpiryDays),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(await Task.FromResult(tokenHandler.WriteToken(token)));
}
private TokenValidationParameters GetTokenValidationParameters(SymmetricSecurityKey signingKey,
JWTSettings jwtSettings)
{
var tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = signingKey,
// Validate the JWT Issuer (iss) claim
ValidateIssuer = true,
ValidIssuer = jwtSettings.Issuer,
// Validate the JWT Audience (aud) claim
ValidateAudience = true,
ValidAudience = jwtSettings.Audience
};
return(tokenValidationParameters);
}
public void InstallService(IServiceCollection services, IConfiguration configuration)
{
//JWT Installer
var jwtSettings = new JWTSettings();
configuration.Bind("jwtSettings", jwtSettings);
services.AddSingleton(jwtSettings);
services.AddTransient <JWTCreator>();
//Authentication
var key = Encoding.UTF8.GetBytes(Environment.GetEnvironmentVariable("Token").ToString());
services.AddAuthentication(opt =>
{
opt.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
opt.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
opt.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(opt => {
opt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false,
ClockSkew = TimeSpan.Zero,
ValidateLifetime = true
};
opt.SaveToken = true;
opt.Events = new JwtBearerEvents
{
OnMessageReceived = context =>
{
if (context.Request.Cookies.ContainsKey("Token"))
{
context.Token = context.Request.Cookies["Token"];
}
return(Task.CompletedTask);
}
};
});
}
public AuthorizationService(UserManager <User> userManager,
IUnitOfWork unitOfWork,
IJWTService jwt,
IEmailService email,
IConfirmationCodeService generateConfirmationCode,
IPasswordService resetPasswordCode,
LinkGenerator linkGenerator,
IHttpContextAccessor httpContextAccessor,
IOptions <JWTSettings> jwtSettings)
{
this.userManager = userManager;
this.jwt = jwt;
this.email = email;
this.generateConfirmationCode = generateConfirmationCode;
this.linkGenerator = linkGenerator;
this.resetPasswordCode = resetPasswordCode;
this.httpContextAccessor = httpContextAccessor;
this.jwtSettings = jwtSettings.Value;
this.unitOfWork = unitOfWork;
this.tokenDataProvider = unitOfWork.Get <ITokenDataProvider>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
services.AddControllers();
AWSOptions options = Configuration.GetAWSOptions();
IAmazonSecretsManager client = options.CreateServiceClient <IAmazonSecretsManager>();
DBSettings DBSecret = JsonConvert.DeserializeObject <DBSettings>(GetDBSecret(client));
JWTSettings JWTSecret = JsonConvert.DeserializeObject <JWTSettings>(GetJWTSecret(client));
services.AddSingleton <DBSettings>(DBSecret);
services.AddSingleton <JWTSettings>(JWTSecret);
// configure jwt authentication
var key = Encoding.ASCII.GetBytes(JWTSecret.JWTSecret);
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
});
// configure DI for application services
services.AddScoped <IJWTService, JWTService>();
services.AddScoped <IDBService, DBService>();
}
public static IServiceCollection AddJWTSecurity(this IServiceCollection services,
JWTSettings settings)
{
var key = Encoding.ASCII.GetBytes(settings.Secret);
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
x.Events = new JwtBearerEvents()
{
//implement unified error messaging approach
OnChallenge = context =>
{
// Skip the default logic.
context.HandleResponse();
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)AppConsts.HttpStatusCodes.Status401Unauthorized;
return(context.Response.WriteAsync(new ExceptionMessage("User is not authenticated.").ToString()));
}
};
});
return(services);
}
private static void ThrowIfInvalidOptions(JWTSettings options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.ValidFor <= TimeSpan.Zero)
{
throw new ArgumentException("Must be a non-zero TimeSpan.", nameof(JWTSettings.ValidFor));
}
if (options.SigningCredentials == null)
{
throw new ArgumentNullException(nameof(JWTSettings.SigningCredentials));
}
if (options.JtiGenerator == null)
{
throw new ArgumentNullException(nameof(JWTSettings.JtiGenerator));
}
}
public static async Task <object> LoginUser(UserViewModel userModel, JWTSettings jwtSettings)
{
if (userModel.Username.Length < 8 || userModel.Password.Length < 8)
{
return("Username or password is shorter than 8 characters.");
}
Context context = new Context();
User found = await context.Users.FirstOrDefaultAsync(u => u.Username == userModel.Username);
if (found == null)
{
return("User with that username does not exists.");
}
found.Token = GenerateAccessToken(found.Id, jwtSettings);
found.TokenCreatedDate = DateTime.Now;
found.TokenExpires = 15;
await context.SaveChangesAsync();
return(found.MapToModel());
}
public static string GenerateAccessToken(JWTSettings options, DateTime issuedTime, string username, string accountId, params string[] permissions)
{
// Specifically add the jti (random nonce), iat (issued timestamp), and sub (subject/user) claims.
// You can add other claims here, if you want:
var claims = new Claim[]
{
new Claim(JwtRegisteredClaimNames.Sub, username),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, (issuedTime.Subtract(new DateTime(1970, 1, 1))).TotalSeconds.ToString(), ClaimValueTypes.Integer64),
new Claim("Account:Id", accountId)
}.Concat(permissions.Select(p => new Claim(ClaimTypes.Role, p)));
// Create the JWT and write it to a string
var jwt = new JwtSecurityToken(
issuer: options.Issuer,
audience: options.Audience,
claims: claims,
notBefore: issuedTime,
expires: issuedTime.Add(options.Expiration),
signingCredentials: options.SigningCredentials);
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
return(encodedJwt);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="commitValidator">CommitValidator (injected)</param>
/// <param name="deleteValidator">DeleteValidator (injected)</param>
/// <param name="context">DBContext (injected)</param>
/// <param name="jwtSettings">The jwt settings</param>
public UsersController(DeleteValidatorBase <User> deleteValidator, CommitValidatorBase <User> commitValidator,
DbContext context, IOptions <JWTSettings> jwtSettings)
: base(deleteValidator, commitValidator, context)
{
this.jwtSettings = jwtSettings.Value;
}
public AdminController(PcHealthContext db, IOptions <JWTSettings> jwtSettings)
{
_db = db;
_jwtSettings = jwtSettings.Value;
}
public UsersController(BlazorDemoDbContext context, IOptions <JWTSettings> jwtsettings)
{
_context = context;
_jwtsettings = jwtsettings.Value;
}
