public IdentityService(UserManager <IdentityUser> userManager, JwtSettings jwtSettings)
{
_userManager = userManager;
_jwtSettings = jwtSettings;
}
static public void LoadRazorAssemblies()
{
if (!_loadDone)
{
try
{
//Force the load of the assemblies
if (dummy == null)
{
dummy = new HtmlString("");
}
if (dummy2 == null)
{
dummy2 = new DataTable();
dummy2.AsEnumerable();
}
if (dummy3 == null)
{
dummy3 = new OleDbConnection();
}
if (dummy4 == null)
{
dummy4 = new LdapConnection("");
}
if (dummy5 == null)
{
dummy5 = new SyndicationFeed();
}
if (dummy6 == null)
{
dummy6 = new XDocument();
}
#if WINDOWS
if (dummy7 == null)
{
dummy7 = new Control();
}
#endif
if (dummy8 == null)
{
dummy8 = new PrincipalContext(ContextType.Machine);
}
if (dummy9 == null)
{
dummy9 = JWT.DefaultSettings;
}
if (dummy10 == null)
{
dummy10 = JObject.Parse("{}");
}
if (dummy11 == null)
{
dummy11 = new FastZip();
}
if (dummy12 == null)
{
dummy12 = new OdbcConnection();
}
if (dummy13 == null)
{
dummy13 = new SqlConnection();
}
if (dummy14 == null)
{
dummy14 = new SftpClient("", "a", "");
}
if (dummy15 == null)
{
dummy15 = new FtpClient();
}
if (dummy16 == null)
{
dummy16 = new HttpClient();
}
if (dummy17 == null)
{
dummy17 = new AdomdConnection();
}
if (dummy18 == null)
{
dummy18 = new ExcelPackage();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
_loadDone = true;
}
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
var jwtSettings = new JwtSettings();
configuration.Bind(nameof(jwtSettings), jwtSettings);
services.AddSingleton(jwtSettings);
services.AddScoped <IAuthService, IdentityService>();
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddFacebook(facebookOptions =>
{
facebookOptions.AppId = "436179993755606";
facebookOptions.AppSecret = "eb4e2758e1d74ad4f2dc10342dad48e8";
})
.AddJwtBearer(x =>
{
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters()
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(jwtSettings.Secret)),
ValidateIssuer = false,
ValidateAudience = false,
RequireExpirationTime = false,
ValidateLifetime = true,
};
});
services
.AddMvc()
.AddFluentValidation(mvcConfiguration => mvcConfiguration.RegisterValidatorsFromAssemblyContaining <Startup>())
.AddJsonOptions(x => x.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore)
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddSwaggerGen(x =>
{
x.SwaggerDoc("v1", new Info {
Title = "Backomm API", Version = "v1"
});
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[0] }
};
x.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description = "JWT Authorization header using the bearer scheme",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
x.AddSecurityRequirement(security);
});
}
public V1Controller(IOptions <JwtSettings> settings)
{
JwtSettings = settings.Value;
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
//binding from config.json to class
var jwtSettings = new JwtSettings();
configuration.Bind(nameof(jwtSettings), jwtSettings);
//object of class adding calss to settings
services.AddSingleton(jwtSettings);
//login
services.AddScoped <IIdentityService, IdentityService>();
services
.AddMvc(options =>
{
options.EnableEndpointRouting = false;
options.Filters.Add <ValidationFilter>();
})
.AddFluentValidation(mvcConfiguration => mvcConfiguration.RegisterValidatorsFromAssemblyContaining <Startup>()) //Automatic registration of all AbstractValidator
.SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
//JWT token
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(PolicyNames.TimB, policy =>
{
policy.AddRequirements(new WorksForCompanyRequirement("TimB.com"));
});
});
services.AddSingleton <IAuthorizationHandler, WorksForCompanyHandler>();
//Pagination
services.AddSingleton <IUriService>(provider =>
{
var accessor = provider.GetRequiredService <IHttpContextAccessor>();
var request = accessor.HttpContext.Request;
var absoluteUri = string.Concat(request.Scheme, "://", request.Host.ToUriComponent(), "/");
return(new UriService(absoluteUri));
});
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
services.AddCors(options =>
{
options.AddPolicy(name: MyAllowSpecificOrigins,
builder =>
{
builder.AllowAnyOrigin()
.AllowAnyHeader()
.AllowAnyMethod();
});
});
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>())
.SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
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("MustWorkForChapsas", policy =>
{
policy.AddRequirements(new WorksForCompanyRequirement("chapsas.com"));
});
});
services.AddSingleton <IAuthorizationHandler, WorksForCompanyHandler>();
services.AddSingleton <IUriService>(provider =>
{
var accessor = provider.GetRequiredService <IHttpContextAccessor>();
var request = accessor.HttpContext.Request;
var absoluteUri = string.Concat(request.Scheme, "://", request.Host.ToUriComponent(), "/");
return(new UriService(absoluteUri));
});
services.AddControllers().AddNewtonsoftJson(options =>
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
);
}
public AuthController(IMapper mapper, UserManager <AppUser> userManager, IOptionsSnapshot <JwtSettings> jwtSettings)
{
_mapper = mapper;
_userManager = userManager;
_jwtSettings = jwtSettings.Value;
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
services.AddMvc(mvcOptions =>
{
mvcOptions.Filters.Add <LastActiveTrackerFilter>();
})
.AddFluentValidation(fluentValidationConfiguration =>
{
fluentValidationConfiguration.RegisterValidatorsFromAssemblyContaining <Startup>();
ValidatorOptions.Global.LanguageManager.Enabled = false;
})
.SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
services.AddCors(options =>
{
options.AddDefaultPolicy(
builder =>
{
builder.WithOrigins("http://localhost:4200", "https://localhost:4200")
.AllowAnyHeader()
.AllowAnyMethod();
});
});
services
.AddControllersWithViews()
.AddNewtonsoftJson(options => options.SerializerSettings.Converters.Add(new StringEnumConverter()));
services.Configure <ApiBehaviorOptions>(options => options.SuppressModelStateInvalidFilter = true);
services.AddScoped <IAuthService, AuthService>();
services.AddTransient <IUsersService, UsersService>();
services.AddTransient <IRolesService, RolesService>();
services.AddTransient <IPropertiesService, PropertiesService>();
services.AddTransient <IPropertyImagesService, PropertyImagesService>();
services.AddTransient <ICountriesService, CountriesService>();
services.AddTransient <ICitiesService, CitiesService>();
services.AddTransient <IBookingsService, BookingsService>();
services.AddTransient <IRefreshTokensService, RefreshTokensService>();
services.AddTransient <IStringHasherService, StringHasherService>();
services.AddTransient <IEmailSender, EmailSender>();
services.AddTransient <ICountriesConverterService, CountriesConverterService>();
services.AddTransient <IAuthenticationServiceHelper, AuthenticationServiceHelper>();
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddTransient <UserResolverService>();
services.AddMediatR(typeof(Startup));
services.AddTransient(typeof(IPipelineBehavior <,>), typeof(ValidationBehavior <,>));
var jwtSettings = new JwtSettings();
configuration.Bind(nameof(JwtSettings), jwtSettings);
services.AddSingleton(jwtSettings);
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(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.SaveToken = true;
x.TokenValidationParameters = tokenValidationParameters;
});
}
public JwtHandler(IOptions <JwtSettings> jwtSettings)
{
_jwtSettings = jwtSettings.Value;
}
public SecurityManager(JwtSettings settings)
{
_settings = settings;
}
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.Filters.Add <ValidationFilter>();
})
.AddFluentValidation(mvcConfiguration => mvcConfiguration.RegisterValidatorsFromAssemblyContaining <Startup>())
.SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
var tokenValidationParameters = new Microsoft.IdentityModel.Tokens.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();
services.AddSingleton <IUriService>(provider =>
{
var accessor = provider.GetRequiredService <IHttpContextAccessor>();
var request = accessor.HttpContext.Request;
var absoluteUri = string.Concat(request.Scheme, "://", request.Host.ToUriComponent(), "/");
return(new UriService(absoluteUri));
});
services.AddSwaggerGen(x => {
x.SwaggerDoc("v1", new Info {
Title = "Storage Api", Version = "v1"
});
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[0] }
};
x.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description = "JWT Authorization header using the bearer scheme",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
x.AddSecurityRequirement(security);
});
}
public JwtMiddleware(RequestDelegate next, IOptions <JwtSettings> jwtSettings)
{
_next = next;
_jwtSettings = jwtSettings.Value;
}
public AuthService(IAccountsService accountsService, JwtSettings jwtSettings)
{
_accountsService = accountsService;
_jwtSettings = jwtSettings;
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
var jwtSettings = new JwtSettings();
configuration.Bind(nameof(jwtSettings), jwtSettings);
services.AddSingleton(jwtSettings);
var tokenValidatorParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(jwtSettings.Secret)),
ValidateIssuer = false,
ValidateAudience = false,
RequireExpirationTime = false,
ValidateLifetime = true,
};
services.AddSingleton(tokenValidatorParameters);
services.AddSingleton <IIdentityServerRequest, IdentityServerRequest>();
services.AddSingleton <IFinanceServerRequest, FinanceServerRequest>();
services.AddScoped <IIdentityService, IdentityService>();
services.AddScoped <IApprovalDetailService, ApprovalDetailService>();
services.AddSingleton <ILoggerService, LoggerService>();
services.AddMvc(options =>
{
options.EnableEndpointRouting = false;
options.Filters.Add <ValidationFilter>();
})
.AddFluentValidation(mvcConfuguration => mvcConfuguration.RegisterValidatorsFromAssemblyContaining <Startup>())
.SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
services.AddCors(options =>
{
options.AddPolicy(MyAllowSpecificOrigins,
builder =>
{
builder.WithOrigins("http://*****:*****@gmail.com",
Url = new Uri("https://twitter.com/FavourE65881201"),
},
License = new OpenApiLicense
{
Name = "GODP API LICX",
Url = new Uri("http://www.GODP.co.uk/"),
},
});
//var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
//var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
//x.IncludeXmlComments(xmlPath);
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[0] }
};
x.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "GODP Cloud Authorization header using bearer scheme",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey,
});
x.AddSecurityRequirement(new OpenApiSecurityRequirement {
{ new OpenApiSecurityScheme {
Reference = new OpenApiReference
{
Id = "Bearer",
Type = ReferenceType.SecurityScheme
}
}, new List <string>() }
});
});
}
public JwtGeneratorService(IOptions <JwtSettings> options, IMediator mediator)
{
_jwtSettings = options.Value;
_mediator = mediator;
}
public LoginController(IOptions <JwtSettings> _jwtSettingsAccess, IYS_Account_UserService account_UserService, ICurrencyService currencyService)
{
_jwtSettings = _jwtSettingsAccess.Value;
_account_UserService = account_UserService;
_currencyService = currencyService;
}
public JwtService(JwtSettings jwtSettings)
{
_jwtSettings = jwtSettings;
}
/// <summary>
/// constructor for security controller
/// </summary>
/// <param name="settings"></param>
/// <param name="mediator"></param>
/// <param name="database"></param>
public SecurityController(JwtSettings settings, IMediator mediator, IBionicRentDatabaseService database)
{
_settings = settings;
_Mediator = mediator;
_database = database;
}
public void ConfigureServices(IServiceCollection services)
{
//services.AddDbContext<TwoButtonsContext>(options => options.UseSqlServer(Configuration.GetConnectionString("TwoButtonsConnection")));
//services.AddTransient<MediaUnitOfWork>();
services.AddSingleton <FileService>();
services.AddSingleton <FolderConfiguration>();
services.AddTransient <MediaService>();
services.AddOptions();
services.Configure <MediaSettings>(Configuration.GetSection("MediaData"));
services.Configure <ServersSettings>(Configuration.GetSection("ServersSettings"));
services.Configure <MediaConverterSettings>(Configuration.GetSection("MediaConverterSettings"));
services.AddSingleton <MediaConverter>();
services.AddMvc();
services.AddCors(options =>
{
options.AddPolicy("AllowAllOrigin", builder => builder.AllowAnyOrigin().AllowAnyHeader()
.AllowAnyMethod());
});
var jwtAppSettingOptions = Configuration.GetSection(nameof(JwtSettings));
var secretKey = jwtAppSettingOptions["SecretKey"];
var issuer = jwtAppSettingOptions[nameof(JwtSettings.Issuer)];
var audience = jwtAppSettingOptions[nameof(JwtSettings.Audience)];
services.Configure <JwtSettings>(options =>
{
options.Issuer = issuer;
options.Audience = audience;
options.SigningCredentials = new SigningCredentials(JwtSettings.CreateSecurityKey(secretKey), SecurityAlgorithms.HmacSha256);
});
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(configureOptions =>
{
configureOptions.ClaimsIssuer = issuer;
configureOptions.RequireHttpsMetadata = false;
configureOptions.TokenValidationParameters = JwtSettings.CreateTokenValidationParameters(issuer, audience, JwtSettings.CreateSecurityKey(secretKey));
});
}
public AuthorizeController(IOptions <JwtSettings> _jwtSettingsAccesser)
{
_jwtSettings = _jwtSettingsAccesser.Value;
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
var jwtSettings = new JwtSettings();
configuration.Bind(nameof(jwtSettings), jwtSettings);
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 = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(jwtSettings.secret)),
ValidateIssuer = false,
ValidateAudience = false,
RequireExpirationTime = false,
ValidateLifetime = true
};
});
services.AddMvc();
services.AddSwaggerGen(x =>
{
x.SwaggerDoc("v1", new OpenApiInfo {
Title = "EpassClient", Version = "v1"
});
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[0] }
};
x.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
{
Description = "JWT Authaurization header using the bearer scheme",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
x.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{ new OpenApiSecurityScheme {
Reference = new OpenApiReference
{
Id = "Bearer",
Type = ReferenceType.SecurityScheme
}
}, new List <string>() }
});
});
}
public void InstallServices(IServiceCollection services, IConfiguration configuration)
{
services.AddMvc(
options => { options.EnableEndpointRouting = false; }
).SetCompatibilityVersion(CompatibilityVersion.Version_3_0);
var jwtSettings = new JwtSettings();
configuration.Bind(key: nameof(jwtSettings), jwtSettings);
services.AddSingleton(jwtSettings);
services.AddScoped <IIdentityService, IdentityService>();
var tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key: Encoding.ASCII.GetBytes(jwtSettings.Secret)),
ValidateAudience = false,
ValidateIssuer = false,
RequireExpirationTime = false,
ValidateLifetime = true
};
services.AddSingleton(tokenValidationParameters);
services.AddAuthentication(configureOptions: auth =>
{
auth.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
auth.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
auth.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(auth =>
{
auth.SaveToken = true;
auth.TokenValidationParameters = tokenValidationParameters;
});
services.AddSwaggerGen(swagger =>
{
swagger.SwaggerDoc("v1", new OpenApiInfo {
Title = "PiTech API", Version = "v1"
});
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[0] }
};
swagger.AddSecurityDefinition(name: "Bearer", new OpenApiSecurityScheme
{
Description = "Jason Web Token Authorization",
Name = "Authorization",
In = ParameterLocation.Header,
Type = SecuritySchemeType.ApiKey
});
swagger.AddSecurityRequirement(new OpenApiSecurityRequirement
{
{
new OpenApiSecurityScheme {
Reference = new OpenApiReference
{
Id = "Bearer",
Type = ReferenceType.SecurityScheme
}
}, new List <string>()
}
});
});
}
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().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddCors();
var tokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters
{
// Most important, validates incoming token with server token from appsettings.json
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();
IdentityBuilder builder = services.AddIdentityCore <IdentityUser>(options =>
{
options.Password.RequireDigit = false;
options.Password.RequiredLength = 4;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
options.User.RequireUniqueEmail = false;
});
services.AddSwaggerGen(x =>
{
x.SwaggerDoc("v1", new Swashbuckle.AspNetCore.Swagger.Info {
Title = "WebApplication1", Version = "v1"
});
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[0] }
};
x.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description = "JWT Authorization header using the bearer scheme",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
x.AddSecurityRequirement(security);
});
}
public static void AddJwtAuthentication(this IServiceCollection services, JwtSettings jwtSettings)
{
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
var secretkey = Encoding.UTF8.GetBytes(jwtSettings.SecretKey);
var encryptionkey = Encoding.UTF8.GetBytes(jwtSettings.Encryptkey);
var validationParameters = new TokenValidationParameters
{
ClockSkew = TimeSpan.Zero, // default: 5 min
RequireSignedTokens = true,
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(secretkey),
RequireExpirationTime = true,
ValidateLifetime = true,
ValidateAudience = true, //default : false
ValidAudience = jwtSettings.Audience,
ValidateIssuer = true, //default : false
ValidIssuer = jwtSettings.Issuer,
TokenDecryptionKey = new SymmetricSecurityKey(encryptionkey)
};
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.TokenValidationParameters = validationParameters;
options.Events = new JwtBearerEvents
{
OnAuthenticationFailed = context =>
{
//var logger = context.HttpContext.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger(nameof(JwtBearerEvents));
//logger.LogError("Authentication failed.", context.Exception);
if (context.Exception != null)
{
throw new AppException(ApiResultStatusCode.UnAuthorized, "Authentication failed.", HttpStatusCode.Unauthorized, context.Exception, null);
}
return(Task.CompletedTask);
},
OnTokenValidated = async context =>
{
var signInManager = context.HttpContext.RequestServices.GetRequiredService <SignInManager <User> >();
var userRepository = context.HttpContext.RequestServices.GetRequiredService <IUserRepository>();
var claimsIdentity = context.Principal.Identity as ClaimsIdentity;
if (claimsIdentity.Claims?.Any() != true)
{
context.Fail("This token has no claims.");
}
var securityStamp = claimsIdentity.FindFirstValue(new ClaimsIdentityOptions().SecurityStampClaimType);
if (!securityStamp.HasValue())
{
context.Fail("This token has no secuirty stamp");
}
//Find user and token from database and perform your custom validation
var userId = claimsIdentity.GetUserId <int>();
var user = await userRepository.GetByIdAsync(context.HttpContext.RequestAborted, userId);
//if (user.SecurityStamp != Guid.Parse(securityStamp))
// context.Fail("Token secuirty stamp is not valid.");
var validatedUser = await signInManager.ValidateSecurityStampAsync(context.Principal);
if (validatedUser == null)
{
context.Fail("Token secuirty stamp is not valid.");
}
if (!user.IsActive)
{
context.Fail("User is not active.");
}
await userRepository.UpdateLastLoginDateAsync(user, context.HttpContext.RequestAborted);
},
OnChallenge = context =>
{
//var logger = context.HttpContext.RequestServices.GetRequiredService<ILoggerFactory>().CreateLogger(nameof(JwtBearerEvents));
//logger.LogError("OnChallenge error", context.Error, context.ErrorDescription);
if (context.AuthenticateFailure != null)
{
throw new AppException(ApiResultStatusCode.UnAuthorized, "Authenticate failure.", HttpStatusCode.Unauthorized, context.AuthenticateFailure, null);
}
throw new AppException(ApiResultStatusCode.UnAuthorized, "You are unauthorized to access this resource.", HttpStatusCode.Unauthorized);
//return Task.CompletedTask;
}
};
});
}
public UserManager(ApplicationContext context, IMapper mapper, JwtSettings jwtSettings)
{
this.context = context;
this.mapper = mapper;
this.jwtSettings = jwtSettings;
}
public AuthController(IOptions <JwtSettings> jwtSettings)
{
_jwtSettings = jwtSettings.Value;
}
public AuthenticationService(JwtSettings jwtSettings)
{
_jwtSettings = jwtSettings;
}
public AuthController(IUserAppService service, IRoleAppService roleService, IOptions <JwtSettings> jwt)
{
_service = service;
_roleService = roleService;
_jwt = jwt.Value;
}
public JwtHandler(JwtSettings settings)
{
_settings = settings;
}
public AuthController(DataContext dataContext, JwtSettings jwtSettings)
{
this.dataContext = dataContext;
this.jwtSettings = jwtSettings;
}