// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
var LockOutOption = new LockoutOptions()
{
AllowedForNewUsers = true,
MaxFailedAccessAttempts = 5,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5)
};
services.AddDbContext <SurveyContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("DefaultConnection")));
services.AddIdentity <ApplicationUser, IdentityRole>(Options => {
Options.Lockout = LockOutOption;
Options.SignIn.RequireConfirmedEmail = true;
})
.AddDefaultUI(UIFramework.Bootstrap4)
.AddEntityFrameworkStores <SurveyContext>().AddDefaultTokenProviders();
services.AddTransient <IEmailSender, EmailSender>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddAuthentication();
}
public static IServiceCollection MongoIdentityService(this IServiceCollection services)
{
services.AddTransient <MongoTablesFactory>();
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(10),
MaxFailedAccessAttempts = 3
};
services.AddDefaultIdentity <ApplicationUser>(opt =>
{
opt.Password.RequireDigit = false;
opt.Password.RequiredLength = 6;
opt.Password.RequireLowercase = false;
opt.Password.RequireNonAlphanumeric = false;
opt.Password.RequireUppercase = false;
opt.Lockout = lockoutOptions;
opt.SignIn.RequireConfirmedAccount = false;
opt.User.RequireUniqueEmail = true;
})
.AddRoles <ApplicationRole>()
.AddDefaultTokenProviders()
.AddRoleStore <MongoRoleStore <ApplicationRole, ObjectId> >()
.AddUserStore <MongoUserStore <ApplicationUser, ObjectId> >();
services.AddScoped <IUserClaimsPrincipalFactory <ApplicationUser>,
AdditionalUserClaimsPrincipalFactory>();
return(services);
}
public void SetLockoutPolicy(LockoutOptions opts)
{
lock (_lock)
{
PolicyOptions.Lockout = opts;
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var lockoutOptions = new LockoutOptions
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(1),
MaxFailedAccessAttempts = 3
};
services.AddIdentity <User, Role>(options =>
{
options.SignIn.RequireConfirmedAccount = true;
options.User.RequireUniqueEmail = true;
options.Lockout = lockoutOptions;
}).AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders()
.AddDefaultUI();
services.AddRouting(options => options.LowercaseUrls = true);
services.AddDbContext <ApplicationDbContext>(options =>
{
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
});
services.AddTransient <IEmailSender, EmailSender>();
services.Configure <AuthMessageSenderOptions>(Configuration);
services.AddControllersWithViews();
services.AddRazorPages();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var lockoutOptionsUsers = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5),
MaxFailedAccessAttempts = 2
};
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddIdentity <ApplicationUser, IdentityRole>(options =>
{
options.Lockout = lockoutOptionsUsers;
options.Password.RequireDigit = false;
options.Password.RequiredLength = 6;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
})
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
// Add application services.
services.AddTransient <IEmailSender, EmailSender>();
services.AddMvc();
}
public IdentityOptions()
{
ClaimsIdentity = new ClaimsIdentityOptions();
User = new UserOptions();
Password = new PasswordOptions();
Lockout = new LockoutOptions();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("DefaultConnection")));
//services.AddDefaultIdentity<IdentityUser>()
// .AddEntityFrameworkStores<ApplicationDbContext>();
var lockoutOption = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(2),
MaxFailedAccessAttempts = 2
};
services.AddIdentity <IdentityUser, IdentityRole>(options => {
options.Lockout = lockoutOption;
})
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultUI()
.AddDefaultTokenProviders();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddTransient <AuthService>();
}
public IdentityOptions()
{
ClaimsIdentity = new ClaimsIdentityOptions();
User = new UserOptions();
Password = new PasswordOptions();
Lockout = new LockoutOptions();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromHours(2),
MaxFailedAccessAttempts = 10
};
services.AddIdentity <ApplicationUser, IdentityRole>(options => { options.Lockout = lockoutOptions; })
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
services.AddSingleton <IFileProvider>(
new PhysicalFileProvider(
Path.Combine(Directory.GetCurrentDirectory(), "wwwroot")));
// Add application services.
services.AddTransient <IEmailSender, EmailSender>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <ISeasonRepository, SeasonRepository>();
services.AddScoped <IPaperRepository, PaperRepository>();
services.AddScoped <IPaperVersionRepository, PaperVersionRepository>();
services.AddScoped <IReviewRepository, ReviewRepository>();
services.AddScoped <IParticipanciesRepository, ParticipanciesRepository>();
services.AddMvc();
}
private static LockoutOptions GetLockoutOptions()
{
LockoutOptions lockoutOptions = new LockoutOptions();
lockoutOptions.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
lockoutOptions.MaxFailedAccessAttempts = 10;
lockoutOptions.AllowedForNewUsers = true;
return(lockoutOptions);
}
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Configuration.GetConnectionString("IdServer4ExampleConnection");
services.AddOptions();
services.Configure <ApplicationOptions>(Configuration.GetSection("ApplicationOptions"));
services.AddDbContext <IdServer4ExampleDbContext>(options =>
{
options.UseSqlServer(connectionString);
});
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromDays(99999),
MaxFailedAccessAttempts = 5
};
services.AddIdentity <ApplicationUser, IdentityRole <Guid> >(option =>
{
option.Lockout = lockoutOptions;
option.User = new UserOptions {
RequireUniqueEmail = true
};
option.Password.RequireDigit = false;
option.Password.RequiredLength = 12;
option.Password.RequiredUniqueChars = 0;
option.Password.RequireLowercase = false;
option.Password.RequireNonAlphanumeric = false;
option.Password.RequireUppercase = false;
})
.AddEntityFrameworkStores <IdServer4ExampleDbContext>()
.AddDefaultTokenProviders();
var migrationsAssembly = typeof(IdServer4ExampleDbContext).GetTypeInfo().Assembly.GetName().Name;
services.AddIdentityServer()
.AddDeveloperSigningCredential()
.AddConfigurationStore(options =>
{
options.ConfigureDbContext = builder =>
builder.UseSqlServer(connectionString,
sql => sql.MigrationsAssembly(migrationsAssembly));
})
.AddOperationalStore(options =>
{
options.ConfigureDbContext = builder =>
builder.UseSqlServer(connectionString,
sql => sql.MigrationsAssembly(migrationsAssembly));
options.EnableTokenCleanup = true;
options.TokenCleanupInterval = 30;
})
.AddAspNetIdentity <ApplicationUser>()
.AddProfileService <ProfileService>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
private LockoutOptions GetLockoutOptions()
{
var lockoutOptions = new LockoutOptions
{
AllowedForNewUsers = true,
MaxFailedAccessAttempts = 5,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5)
};
return(lockoutOptions);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromSeconds(30),
MaxFailedAccessAttempts = 3
};
services.Configure <CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
});
services.Configure <IdentityOptions>(options =>
{
options.Password.RequireDigit = false;
options.Password.RequiredLength = 5;
options.Password.RequireLowercase = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Lockout = lockoutOptions;
});
services.AddDbContext <LMSContext>(options => {
options.EnableSensitiveDataLogging();
options.UseSqlServer(
Configuration.GetConnectionString("DefaultConnection"));
});
services.AddDefaultIdentity <User>()
.AddRoles <Role>()
.AddDefaultUI(UIFramework.Bootstrap4)
.AddEntityFrameworkStores <LMSContext>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IBookService, BookService>();
services.AddScoped <IAuthorService, AuthorService>();
services.AddScoped <IMembershipService, MembershipService>();
services.AddScoped <ISubjectCategoryService, SubjectCategoryService>();
services.AddScoped <IBanService, BanService>();
services.AddScoped <IHistoryService, HistoryService>();
services.AddScoped <INotificationService, NotificationService>();
services.AddScoped <INotificationManager, NotificationManager>();
services.AddScoped <IReviewService, ReviewService>();
services.AddScoped <IReservationService, ReservationService>();
services.AddScoped <IRoleManagerService, RoleManagerService>();
services.AddScoped <IJsonManager, JsonManager>();
services.AddScoped <IMapVmToDTO, MapVmToDTO>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddHostedService <ReturningBooksService>();
services.AddMvc().AddNToastNotifyToastr();
}
private void SetLockoutSharedPolicy(LockoutPolicy policy, LockoutOptions shared = null)
{
if (shared == null)
{
shared = _sharedPolicyAccessor.GetPolicy().Lockout;
}
shared.AllowedForNewUsers = policy.AllowedForNewUsers;
shared.DefaultLockoutTimeSpan = policy.DefaultLockoutTimeSpan;
shared.MaxFailedAccessAttempts = policy.MaxFailedAccessAttempts;
_sharedPolicyAccessor.SetLockoutPolicy(shared);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <NeptuneContext>(options => options.UseSqlite("Data Source=neptune.db"));
services.AddIdentity <User, IdentityRole>()
.AddEntityFrameworkStores <NeptuneContext>()
.AddDefaultTokenProviders();
services.AddMvc();
//services.AddDistributedMemoryCache();
//services.AddSession();
services.AddBootstrapPagerGenerator(options => options.ConfigureDefault());
services.AddTransient <UserService>();
services.AddTransient <AlbumService>();
services.AddTransient <ImageService>();
services.AddTransient <CategoryService>();
services.AddTransient <UnitOfWork>();
services.AddTransient <Seeder>();
var userOptions = new UserOptions {
RequireUniqueEmail = true
};
var passwordOptions = new PasswordOptions
{
RequireDigit = false,
RequiredLength = 1,
RequireNonAlphanumeric = false,
RequireUppercase = false,
RequireLowercase = false
};
var lockoutOptions = new LockoutOptions
{
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(1),
MaxFailedAccessAttempts = 10
};
services.Configure <IdentityOptions>(options =>
{
options.Password = passwordOptions;
options.Lockout = lockoutOptions;
options.User = userOptions;
});
}
public static void GetIdentityOptions(IdentityOptions options)
{
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromDays(1),
MaxFailedAccessAttempts = MaxFailedAttemptsCount
};
options.Password.RequireDigit = false;
options.Password.RequireLowercase = false;
options.Password.RequireUppercase = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequiredLength = 8;
options.SignIn.RequireConfirmedEmail = true;
options.Lockout = lockoutOptions;
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.Configure <WebEncoderOptions>(options => new TextEncoderSettings(UnicodeRanges.All));
services.AddTransient <IPhotoUploadService, PhotoUploadService>();
services.AddTransient(typeof(IDataRepository <>), typeof(DataRepository <>));
services.AddTransient <IDataRepository <Item>, ItemsDataRepository>();
services.AddTransient <IOrderService, OrderService>();
services.Configure <PasswordHasherOptions>(options =>
options.CompatibilityMode = PasswordHasherCompatibilityMode.IdentityV2
);
var lockoutOptions = new LockoutOptions
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(15),
MaxFailedAccessAttempts = 3
};
services.AddEntityFrameworkInMemoryDatabase().AddDbContext <UserContext>((serviceProvider, options) => options.UseInMemoryDatabase("Users").UseInternalServiceProvider(serviceProvider));
services.AddDbContext <IncantoDataContext>(optionsAction =>
optionsAction.UseSqlServer(Configuration.GetConnectionString("DevelopersConnection")));
services.AddIdentity <ApplicationUser, IdentityRole>(options =>
{
// Lockout settings
options.Lockout = lockoutOptions;
})
.AddEntityFrameworkStores <UserContext>()
.AddDefaultTokenProviders();
services.AddMvc();
services.ConfigureApplicationCookie(options =>
{
// Cookie settings
options.Cookie.HttpOnly = true;
options.Cookie.Expiration = TimeSpan.FromDays(60);
options.LoginPath = "/admin/login";
options.LogoutPath = "/admin/logout";
options.AccessDeniedPath = "/admin/AccessDenied";
options.SlidingExpiration = true;
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var lockout = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5),
MaxFailedAccessAttempts = 3
};
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddDefaultIdentity <User>(options =>
{ options.SignIn.RequireConfirmedAccount = true;
options.Lockout = lockout; })
.AddRoles <IdentityRole>()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
services.AddTransient <AdministratorSeedData>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddControllersWithViews();
services.AddRazorPages().AddRazorRuntimeCompilation();
}
private static void setLockoutOptions(LockoutOptions identityOptionsLockout, SiteSettings siteSettings)
{
identityOptionsLockout.AllowedForNewUsers = siteSettings.LockoutOptions.AllowedForNewUsers;
identityOptionsLockout.DefaultLockoutTimeSpan = siteSettings.LockoutOptions.DefaultLockoutTimeSpan;
identityOptionsLockout.MaxFailedAccessAttempts = siteSettings.LockoutOptions.MaxFailedAccessAttempts;
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Environment.GetEnvironmentVariable("SHOPPING_CART_CONECTION_STRING") ?? Configuration.GetConnectionString("SqlConnection");
services.AddDbContext <IdentityContext>(options => options.UseSqlServer(connectionString));
var lockoutOptions = new LockoutOptions
{
AllowedForNewUsers = Convert.ToBoolean(Configuration["Account:UserLockoutEnabledByDefault"]),
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(double.Parse(Configuration["Account:DefaultAccountLockoutTimeSpan"])),
MaxFailedAccessAttempts = Convert.ToInt32(Configuration["Account:MaxFailedAccessAttemptsBeforeLockout"])
};
services.AddIdentity <User, Role>(options =>
{
options.Lockout = lockoutOptions;
options.SignIn.RequireConfirmedEmail = Convert.ToBoolean(Configuration["Account:RequireConfirmedEmail"]);
options.User.RequireUniqueEmail = true;
options.Password.RequiredLength = Convert.ToInt32(Configuration["Account:PasswordRequiredLength"]);
}).AddEntityFrameworkStores <IdentityContext>().AddDefaultTokenProviders();
services.Configure <DataProtectionTokenProviderOptions>(options =>
{
options.TokenLifespan = TimeSpan.FromHours(Convert.ToInt32(Configuration["Account:TokenExpirationTimeSpan"]));
});
services.AddScoped <IAuthApplicationService, AuthApplicationService>();
services.AddScoped <IRoleApplicationService, RoleApplicationService>();
services.AddScoped <IUserApplicationService, UserApplicationService>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IRoleRepository, RoleRepository>();
services.AddScoped <IUnitOfWork, UnitOfWork>();
services.AddTransient <DbInitializer>();
services.AddAuthorization(cfg =>
{
cfg.AddPolicy("Administrator", p => p.RequireClaim(ClaimTypes.Role, Roles.Admin));
cfg.AddPolicy("Member", p => p.RequireClaim(ClaimTypes.Role, Roles.Member));
});
var tokenKey = Environment.GetEnvironmentVariable("JWT_TOKEN_KEY") ?? Configuration["Jwt:Key"];
services.AddAuthentication(o =>
{
o.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, cfg =>
{
cfg.RequireHttpsMetadata = false;
cfg.TokenValidationParameters = new TokenValidationParameters
{
ValidIssuer = Environment.GetEnvironmentVariable("JWT_ISSUER") ?? Configuration["Jwt:Issuer"],
ValidAudience = Environment.GetEnvironmentVariable("JWT_AUDIENCE") ?? Configuration["Jwt:Audience"],
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(tokenKey))
};
});
var allowSpecificOriginUrl = Environment.GetEnvironmentVariable("ALLOW_SPECIFIC_ORIGIN_URL") ?? Configuration["AllowSpecificOriginUrl"];
services.AddCors(options =>
{
options.AddPolicy("AllowSpecificOrigin",
builder => builder
.WithOrigins(allowSpecificOriginUrl)
.AllowAnyMethod()
.AllowCredentials()
.AllowAnyHeader());
});
services.AddAutoMapper();
services.AddMvc(options =>
{
options.Filters.Add(
new ProducesResponseTypeAttribute(typeof(ErrorResponse), 400));
options.Filters.Add(
new ProducesResponseTypeAttribute(typeof(ErrorResponse), 401));
options.Filters.Add(
new ProducesResponseTypeAttribute(typeof(ErrorResponse), 403));
options.Filters.Add(
new ProducesResponseTypeAttribute(typeof(ErrorResponse), 404));
options.Filters.Add(
new ProducesResponseTypeAttribute(typeof(ErrorResponse), 415));
options.Filters.Add(
new ProducesResponseTypeAttribute(typeof(ErrorResponse), 500));
options.Filters.Add(new CorsAuthorizationFilterFactory("AllowSpecificOrigin"));
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "System API", Version = "v1"
});
c.AddSecurityDefinition("Bearer", new ApiKeyScheme()
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
c.AddSecurityRequirement(new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[] { } }
});
c.CustomSchemaIds(x => x.FullName);
});
}
public void ConfigureServices(IServiceCollection services)
{
var config = new AutoMapper.MapperConfiguration(
cfg =>
{
cfg.CreateMap <TransactionViewModel, Data.Entities.Transaction>();
cfg.CreateMap <Data.Entities.Transaction, TransactionViewModel>();
cfg.CreateMap <LogViewModel, Log>();
cfg.CreateMap <Log, LogViewModel>();
cfg.CreateMap <Data.Entities.Transaction, TransactionViewModel>()
.ForMember(f => f.StatusMessage, o => o.Ignore());
});
var mapper = config.CreateMapper();
services.AddSingleton(mapper);
services.AddDbContext <ApplicationDbContext>(
options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5),
MaxFailedAccessAttempts = 5
};
services.AddIdentity <ApplicationUser, IdentityRole>(options => { options.Lockout = lockoutOptions; })
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
services.ConfigureApplicationCookie(options =>
{
options.SlidingExpiration = true;
});
// Add application services.
services.AddTransient <IEmailSender, EmailSender>(provider => new EmailSender(Configuration));
services.AddTransient <IRequestProvider, RequestProvider>();
services.AddScoped <IMerchantRepository, MerchantRepository>();
services.AddScoped <ITransactionRepository, TransactionRepository>();
services.AddScoped <ILogRepository, LogRepository>();
services.AddScoped <ISubscriptionsRepository, SubscriptionsRepository>();
services.AddScoped <IBitcoinService, BitcoinService>(provider => new BitcoinService(Network.GetNetwork(Configuration.GetValue <string>("BitcoinNetwork"))));
services.AddScoped <IEthereumService, EthereumService>(provider => new EthereumService(Configuration.GetValue <string>("EthereumNetwork"), Configuration.GetValue <string>("EthereumWords"), Configuration.GetValue <string>("EthereumPassword")));
services.AddMvc();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "Safecryptotrades API", Version = "v1"
});
var basePath = AppContext.BaseDirectory;
var xmlPath = Path.Combine(basePath, "payment.xml");
c.IncludeXmlComments(xmlPath);
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var conString = Configuration.GetConnectionString("DbConnectionPost");
if (CurrentEnvironment.IsProduction())
{
conString = Environment.GetEnvironmentVariable("TAXI_DB_CONN");
}
services.AddDbContext <ApplicationDbContext>(options =>
options.UseNpgsql(conString,
b => {
b.MigrationsAssembly("Taxi");
b.UseNetTopologySuite();
b.EnableRetryOnFailure(20, TimeSpan.FromMinutes(0.5),
errorCodesToAdd: null);
}));
// services.AddScoped<ApplicationDbContext, ApplicationDbContext>();
services.AddScoped <IDriverLocRepository, DriverLocationRepository>();
services.AddScoped <IUsersRepository, UsersRepository>();
services.AddTransient <IJwtFactory, JwtFactory>();
services.TryAddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped <ITripsRepository, TripsRepository>();
services.AddScoped <IUploadService, UploadSevice>();
services.AddScoped <IGoogleMapsService, GoogleMapsService>();
services.TryAddSingleton <IActionContextAccessor, ActionContextAccessor>();
services.AddScoped <IUrlHelper, UrlHelper>(implamantationFactory =>
{
var actionContext =
implamantationFactory.GetService <IActionContextAccessor>().ActionContext;
return(new UrlHelper(actionContext));
});
services.AddScoped <IResourceUriHelper, ResourceUriHelper>();
services.AddSignalR();
var awsopt = Configuration.GetAWSOptions();
var keyId = Environment.GetEnvironmentVariable("AWS_ACCESS_KEY_ID");
var secretKey = Environment.GetEnvironmentVariable("AWS_SECRET_ACCESS_KEY");
var creds = new BasicAWSCredentials(keyId, secretKey);
awsopt.Credentials = creds;
services.AddDefaultAWSOptions(awsopt);
services.AddAWSService <IAmazonS3>();
var keyFromConfig = Configuration["JWT_KEY"];
if (keyFromConfig == null)
{
keyFromConfig = Guid.NewGuid().ToString();
}
SymmetricSecurityKey signingKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(keyFromConfig));
var jwtOptions = Configuration.GetSection(nameof(JwtIssuerOptions));
services.Configure <JwtIssuerOptions>(options =>
{
options.Issuer = jwtOptions[nameof(JwtIssuerOptions.Issuer)];
options.Audience = jwtOptions[nameof(JwtIssuerOptions.Audience)];
options.SigningCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
});
services.Configure <GoogleApiOptions>(opts =>
{
opts.ApiKey = Configuration["GOOGLE_API_KEY"];
});
services.Configure <BaseUrl>(opts =>
{
opts.BaseWebUrl = Configuration["BaseWebUrl"];
});
var tokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidIssuer = jwtOptions[nameof(JwtIssuerOptions.Issuer)],
ValidateAudience = true,
ValidAudience = jwtOptions[nameof(JwtIssuerOptions.Audience)],
ValidateIssuerSigningKey = true,
IssuerSigningKey = signingKey,
RequireExpirationTime = false,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero
};
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(configureOptions =>
{
configureOptions.ClaimsIssuer = jwtOptions[nameof(JwtIssuerOptions.Issuer)];
configureOptions.TokenValidationParameters = tokenValidationParameters;
configureOptions.SaveToken = true;
configureOptions.Events = new JwtBearerEvents
{
OnMessageReceived = context =>
{
var accessToken = context.Request.Query["access_token"];
// If the request is for our hub...
var path = context.HttpContext.Request.Path;
if (!string.IsNullOrEmpty(accessToken))
{
// Read the token out of the query string
context.Token = accessToken;
}
return(Task.CompletedTask);
}
};
});
// api user claim policy
services.AddAuthorization(options =>
{
options.AddPolicy("Customer", policy => policy.RequireClaim(Constants.Strings.JwtClaimIdentifiers.Rol, Constants.Strings.JwtClaims.CustomerAccess));
options.AddPolicy("Driver", policy => policy.RequireClaim(Constants.Strings.JwtClaimIdentifiers.Rol, Constants.Strings.JwtClaims.DriverAccess));
options.AddPolicy("DriverReg", policy => policy.RequireClaim(Constants.Strings.JwtClaimIdentifiers.DriverId));
options.AddPolicy("Admin", policy => policy.RequireClaim(Constants.Strings.JwtClaimIdentifiers.Rol, Constants.Strings.JwtClaims.AdminAccess));
options.AddPolicy("Root", policy => policy.RequireClaim(Constants.Strings.JwtClaimIdentifiers.Rol, Constants.Strings.JwtClaims.RootUserAccess));
});
services.Configure <EmailSenderOptions>(Configuration.GetSection("email"));
services.AddTransient <IEmailSender, EmailSender>();
//identity configuration
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5),
MaxFailedAccessAttempts = 5
};
var builder = services.AddIdentityCore <AppUser>(o =>
{
// configure identity options
o.Password.RequireDigit = false;
o.Password.RequireLowercase = false;
o.Password.RequireUppercase = false;
o.Password.RequireNonAlphanumeric = false;
o.Password.RequiredLength = 6;
o.Lockout = lockoutOptions;
});
builder = new IdentityBuilder(builder.UserType, typeof(IdentityRole), builder.Services);
builder.AddEntityFrameworkStores <ApplicationDbContext>().AddDefaultTokenProviders();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "Taxi api", Version = "v1"
});
c.AddSecurityDefinition("Bearer",
new ApiKeyScheme
{
In = "header",
Description = "Please enter JWT with Bearer into field",
Name = "Authorization",
Type = "apiKey"
});
c.AddSecurityRequirement(new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", Enumerable.Empty <string>() }
});
c.OperationFilter <FileUploadOperation>();
});
services.AddMemoryCache();
services.AddAutoMapper();
services.AddCors();
services.AddMvc();
}
public void ConfigureServices(IServiceCollection services)
{
services.Scan(scan => scan
.FromAssembliesOf(typeof(IRequest), typeof(AddUserRequest))
.AddClasses()
.AsSelf()
.WithScopedLifetime());
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.Configure <DataProtectionTokenProviderOptions>(options =>
{
options.TokenLifespan = TimeSpan.FromDays(7);
});
services.AddOptions();
var connectionString = Configuration.GetConnectionString("RecipeTrackerConnection");
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromDays(99999),
MaxFailedAccessAttempts = 5
};
services.AddDbContext <RecipeTrackerDbContext>(options =>
{
options.UseSqlServer(connectionString);
});
services.AddIdentity <ApplicationUser, IdentityRole <Guid> >(option =>
{
option.Lockout = lockoutOptions;
option.User = new UserOptions {
RequireUniqueEmail = true
};
option.Password.RequireDigit = false;
option.Password.RequiredLength = 12;
option.Password.RequiredUniqueChars = 0;
option.Password.RequireLowercase = false;
option.Password.RequireNonAlphanumeric = false;
option.Password.RequireUppercase = false;
})
.AddEntityFrameworkStores <RecipeTrackerDbContext>()
.AddDefaultTokenProviders();
var provider = services.BuildServiceProvider();
services.AddMvc(config =>
{
config.ModelMetadataDetailsProviders.Add(new RequestInjectionMetadataProvider());
config.ModelBinderProviders.Insert(0, new QueryModelBinderProvider(provider));
config.Filters.Add(new ValidationFilter());
config.Filters.Add(new AuthorizeFilter());
})
.AddJsonOptions(options =>
{
options.SerializerSettings.Converters.Add(new RequestInjectionHandler <IRequest>(provider));
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
options.SerializerSettings.DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Local;
options.SerializerSettings.DateFormatString = "MM/dd/yy HH:mm";
})
.AddFluentValidation(c =>
{
c.RegisterValidatorsFromAssemblyContaining <AddUserRequest>();
c.RegisterValidatorsFromAssemblyContaining <ApplicationUserValidator>();
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "Recipe Tracker API", Version = "v1"
});
});
var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
services.AddIdentityServer()
.AddDeveloperSigningCredential()
.AddConfigurationStore(options =>
{
options.ConfigureDbContext = builder =>
builder.UseSqlServer(connectionString,
sql => sql.MigrationsAssembly(migrationsAssembly));
})
.AddOperationalStore(options =>
{
options.ConfigureDbContext = builder =>
builder.UseSqlServer(connectionString,
sql => sql.MigrationsAssembly(migrationsAssembly));
options.EnableTokenCleanup = true;
options.TokenCleanupInterval = 30;
})
.AddAspNetIdentity <ApplicationUser>()
.AddProfileService <ProfileService>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// services.AddDbContext<DataContext>(x => x.UseMySql(Configuration
// .GetConnectionString("DefaultConnection")));
services.AddDbContext <DataContext>(x => x.UseMySql(Configuration
.GetConnectionString("DefaultConnection"),
new MySqlServerVersion(new Version(8, 0, 21)),
mySqlOptions => mySqlOptions
.CharSetBehavior(CharSetBehavior.NeverAppend)));
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(10),
MaxFailedAccessAttempts = 5
};
// for role and identity authentication
// initial creation of user in the user table in database
IdentityBuilder builder = services.AddIdentityCore <User>(opt =>
{
// password requirements
opt.Lockout = lockoutOptions;
opt.Password.RequireDigit = true;
opt.Password.RequiredLength = 8;
opt.Password.RequireNonAlphanumeric = false;
opt.Password.RequireUppercase = true;
});
builder = new IdentityBuilder(builder.UserType, typeof(Role), builder.Services);
builder.AddEntityFrameworkStores <DataContext>();
builder.AddRoleValidator <RoleValidator <Role> >();
builder.AddRoleManager <RoleManager <Role> >();
builder.AddSignInManager <SignInManager <User> >();
// allows api to use authentication
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII
.GetBytes(Configuration.GetSection("AppSettings:Token").Value)),
ValidateIssuer = false,
ValidateAudience = false
};
});
// authorisation policy
services.AddAuthorization(options =>
{
options.AddPolicy("AdminAccess", policy => policy.RequireRole("Admin"));
options.AddPolicy("everyone", policy => policy.RequireRole("Admin", "standard"));
});
services.AddControllers(options =>
{
var policy = new AuthorizationPolicyBuilder()
.RequireAuthenticatedUser()
.Build();
options.Filters.Add(new AuthorizeFilter(policy));
})
.AddNewtonsoftJson(opt =>
{
opt.SerializerSettings.ReferenceLoopHandling =
Newtonsoft.Json.ReferenceLoopHandling.Ignore;
});
services.AddScoped <ITaskScheduleRepository, TaskScheduleRepository>();
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <INotesRepository, NotesRepository>();
services.AddScoped <IAttachmentFileRepository, AttachmentFileRepository>();
services.AddScoped <ICustomerRepository, CustomerRepository>();
services.AddScoped <IReportRepository, ReportRepository>();
services.AddControllers();
services.AddCors();
//allows use of tokens
// Auto Mapper Configurations
var mappingConfig = new MapperConfiguration(mc =>
{
mc.AddProfile(new AutoMapperProfiles());
});
IMapper mapper = mappingConfig.CreateMapper();
services.AddSingleton(mapper);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddEntityFrameworkMySql();
services.AddDbContext <MyContext>(options =>
options.UseMySql(Configuration.GetConnectionString("MyConnection")));
var connectionString = new ConnectionString(Configuration.GetConnectionString("MyConnection"));
services.AddSingleton(connectionString);
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5),
MaxFailedAccessAttempts = 3
};
services.AddSession(options =>
{
// Set a short timeout for easy testing.
options.IdleTimeout = TimeSpan.FromMinutes(5);
options.Cookie.HttpOnly = true;
// Make the session cookie essential
options.Cookie.IsEssential = true;
options.Cookie.SameSite = SameSiteMode.Lax;
});
services.AddIdentity <Employee, Role>(options =>
{
options.Lockout.AllowedForNewUsers = true;
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
options.Lockout.MaxFailedAccessAttempts = 3;
})
.AddEntityFrameworkStores <MyContext>()
.AddDefaultTokenProviders();
services.AddSession(options =>
{
// Set a short timeout for easy testing.
options.IdleTimeout = TimeSpan.FromMinutes(5);
options.Cookie.HttpOnly = false;
// Make the session cookie essential
options.Cookie.IsEssential = true;
});
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme).AddJwtBearer(options =>
{
options.RequireHttpsMetadata = false;
options.SaveToken = true;
options.TokenValidationParameters = new Microsoft.IdentityModel.Tokens.TokenValidationParameters()
{
ValidateIssuer = true,
ValidateAudience = false,
ValidAudience = Configuration["Jwt:Audience"],
ValidIssuer = Configuration["Jwt:Issuer"],
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:Key"]))
};
});
services.AddAuthorization(options =>
{
options.AddPolicy(
"Role",
policyBuilder => policyBuilder.AddRequirements(
new AccessControl("Admin")));
});
services.Configure <IISOptions>(options =>
{
options.AutomaticAuthentication = false;
});
services.ConfigureApplicationCookie(options => options.LoginPath = "/Users/Login");
services.AddScoped <IUserRepository, UserRepository>();
services.AddScoped <IUserService, UserService>();
services.AddScoped <IRoleRepository, RoleRepository>();
services.AddScoped <IRoleService, RoleService>();
services.AddScoped <ApplicationRepository>();
services.AddScoped <ApplicationUserRepository>();
services.AddScoped <BatchRepository>();
services.AddScoped <BootcampRepository>();
services.AddScoped <DegreeRepository>();
services.AddScoped <DepartmentRepository>();
services.AddScoped <DivisionRepository>();
services.AddScoped <JobTitleRepository>();
services.AddScoped <MajorRepository>();
services.AddScoped <ProvinceRepository>();
services.AddScoped <RegencyRepository>();
services.AddScoped <ReligionRepository>();
services.AddSingleton <IAuthorizationHandler, IsAdminHandler>();
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.Configure <TwoFactorOptions>(Configuration.GetSection("TwoFactorOptions"));
services.AddDbContext <AppIdentityDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultAzureConnectionString")));
//services.AddDbContext<AppIdentityDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnectionString")));
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromSeconds(30),
MaxFailedAccessAttempts = 3
};
services.AddAuthentication().AddFacebook(options =>
{
options.AppId = Configuration["Authentication:Facebook:AppId"];
options.AppSecret = Configuration["Authentication:Facebook:AppSecret"];
}).AddGoogle(options =>
{
options.ClientId = Configuration["Authentication:Google:ClientID"];
options.ClientSecret = Configuration["Authentication:Google:ClientSecret"];
});
//.AddMicrosoftAccount(opts =>
// {
// opts.ClientId = Configuration["Authentication:Microsoft:ClientID"];
// opts.ClientSecret = Configuration["Authentication:Microsoft:ClientSecret"];
// })
//services.AddAuthentication(AzureADDefaults.AuthenticationScheme)
// .AddAzureAD(options => Configuration.Bind("AzureAd", options));
//services.Configure<OpenIdConnectOptions>(AzureADDefaults.OpenIdScheme, options =>
//{
// options.Authority = options.Authority + "/v2.0/";
// options.TokenValidationParameters.ValidateIssuer = false;
//});
services.AddIdentity <AppUser, AppRole>(options =>
{
options.Lockout = lockoutOptions;
options.User.RequireUniqueEmail = true;
options.User.AllowedUserNameCharacters = "abcçdefgğhıijklmnoöpqrsştuüvwxyzABCÇDEFGHIİJKLMNOÖPQRSŞTUÜVWXYZ0123456789-._";
// Password validation
options.Password.RequiredLength = 4;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireDigit = true; // number between 0-9
options.Password.RequireLowercase = false;
options.Password.RequireUppercase = false;
})
.AddUserValidator <CustomValidation.CustomUserValidator>()
.AddPasswordValidator <CustomValidation.CustomPasswordValidator>()
.AddErrorDescriber <CustomValidation.CustomIdentityErrorDescriber>()
.AddEntityFrameworkStores <AppIdentityDbContext>()
.AddDefaultTokenProviders();
CookieBuilder cookieBuilder = new CookieBuilder();
cookieBuilder.Name = "MyBlog";
cookieBuilder.HttpOnly = false;
cookieBuilder.SameSite = SameSiteMode.Lax;
cookieBuilder.SecurePolicy = CookieSecurePolicy.SameAsRequest;
services.ConfigureApplicationCookie(options =>
{
options.LoginPath = new PathString("/Home/Login");
options.LogoutPath = new PathString("/Member/LogOut");
options.Cookie = cookieBuilder;
options.ExpireTimeSpan = System.TimeSpan.FromDays(60);
options.SlidingExpiration = true;
});
services.AddMvc(option => option.EnableEndpointRouting = false);
}
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Configuration.GetConnectionString("IdServer4ExampleConnection");
services.AddDbContext <IdServer4ExampleDbContext>(options =>
{
options.UseSqlServer(connectionString);
});
services.AddDistributedMemoryCache();
var lockoutOptions = new LockoutOptions()
{
AllowedForNewUsers = true,
DefaultLockoutTimeSpan = TimeSpan.FromDays(99999),
MaxFailedAccessAttempts = 5
};
services.AddIdentity <ApplicationUser, IdentityRole <Guid> >(option =>
{
option.Lockout = lockoutOptions;
option.User = new UserOptions {
RequireUniqueEmail = true
};
option.Password.RequireDigit = false;
option.Password.RequiredLength = 12;
option.Password.RequiredUniqueChars = 0;
option.Password.RequireLowercase = false;
option.Password.RequireNonAlphanumeric = false;
option.Password.RequireUppercase = false;
})
.AddEntityFrameworkStores <IdServer4ExampleDbContext>()
.AddDefaultTokenProviders();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddCors(options =>
{
options.AddPolicy("corspolicy", policy =>
{
policy.WithOrigins("https://localhost:44322")
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials();
});
});
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddIdentityServerAuthentication(options =>
{
options.Authority = "https://localhost:44386";
options.RequireHttpsMetadata = false;
options.ApiName = "exampleapi";
});
services.AddMvc(options => options.Filters.Add(new RequireHttpsAttribute()));
services.AddAuthorization(c =>
{
c.AddPolicy("exampleapi", p => p.RequireClaim("scope", "exampleapi"));
});
}
public static IServiceCollection AddCustomIdentity(
this IServiceCollection services,
PasswordOptions passwordPolicies,
LockoutPolicies lockoutPolicies,
SignInOptions signinPolicies)
{
services
.AddIdentity <AppUser, AppRole>()
.AddDefaultTokenProviders();
services.Configure <IdentityOptions>(opts =>
{
// Password settings.
PasswordOptions passwordOpts = opts.Password;
passwordOpts.RequireDigit = passwordPolicies.RequireDigit;
passwordOpts.RequiredLength = passwordPolicies.RequiredLength;
passwordOpts.RequiredUniqueChars = passwordPolicies.RequiredUniqueChars;
passwordOpts.RequireNonAlphanumeric = passwordPolicies.RequireNonAlphanumeric;
passwordOpts.RequireLowercase = passwordPolicies.RequireLowercase;
passwordOpts.RequireUppercase = passwordPolicies.RequireUppercase;
// Lockout settings.
LockoutOptions lockoutOpts = opts.Lockout;
lockoutOpts.AllowedForNewUsers = lockoutPolicies.AllowedForNewUsers;
lockoutOpts.MaxFailedAccessAttempts = lockoutPolicies.MaxFailedAccessAttempts;
lockoutOpts.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(lockoutPolicies.DefaultLockoutInMinutes);
// User settings.
//options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@";
opts.User.RequireUniqueEmail = true;
// SignIn settings.
SignInOptions signinOpts = opts.SignIn;
signinOpts.RequireConfirmedEmail = signinPolicies.RequireConfirmedEmail;
signinOpts.RequireConfirmedPhoneNumber = signinPolicies.RequireConfirmedPhoneNumber;
});
//services.ConfigureApplicationCookie(options =>
//{
// // Cookie settings.
// // options.LoginPath = string.Empty;
// // options.LogoutPath = string.Empty;
// // options.AccessDeniedPath = string.Empty;
// options.Events = new CookieAuthenticationEvents
// {
// OnRedirectToLogin = ctx =>
// {
// if (ctx.Request.Path.StartsWithSegments("/api") &&
// ctx.Response.StatusCode == (int)HttpStatusCode.OK)
// {
// ctx.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
// }
// else
// {
// ctx.Response.Redirect(ctx.RedirectUri);
// }
// return Task.CompletedTask;
// }
// };
//});
return(services);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ApplicationContext>(ServiceLifetime.Scoped);
services.AddScoped <IDbContext>(_ => new ApplicationContext(Configuration));
services.AddTransient <DbInitializer>();
services.AddTransient <IdentityInitializer>();
var lockoutOptions = new LockoutOptions
{
AllowedForNewUsers = Convert.ToBoolean(Configuration["Account:UserLockoutEnabledByDefault"]),
DefaultLockoutTimeSpan = TimeSpan.FromMinutes(Double.Parse(Configuration["Account:DefaultAccountLockoutTimeSpan"])),
MaxFailedAccessAttempts = Convert.ToInt32(Configuration["Account:MaxFailedAccessAttemptsBeforeLockout"])
};
services.AddIdentity <User, Role>(options =>
{
options.Lockout = lockoutOptions;
}).AddEntityFrameworkStores <ApplicationContext>()
.AddDefaultTokenProviders();
services.Configure <DataProtectionTokenProviderOptions>(options =>
{
options.TokenLifespan = TimeSpan.FromHours(Convert.ToInt32(Configuration["Account:TokenExpirationTimeSpan"]));
});
services.AddScoped <IUserRepository>(_ => new UserRepository(_.GetService <IUnitOfWork>()));
services.AddScoped <IRoleRepository>(_ => new RoleRepository(_.GetService <IUnitOfWork>()));
services.AddScoped <IUnitOfWork>(_ => new UnitOfWork(_.GetService <IDbContext>()));
services.AddAuthorization(cfg =>
{
cfg.AddPolicy("Administrator", p => p.RequireClaim(ClaimTypes.Role, "Admin"));
});
services.AddAuthentication().AddJwtBearer(cfg =>
{
cfg.RequireHttpsMetadata = false;
cfg.SaveToken = true;
cfg.TokenValidationParameters = new TokenValidationParameters
{
ValidIssuer = Configuration["Tokens:Issuer"],
ValidAudience = Configuration["Tokens:Issuer"],
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Tokens:Key"]))
};
});
services.ConfigureApplicationCookie(options =>
{
options.Events.OnRedirectToLogin = (ctx) =>
{
if (ctx.Request.Path.StartsWithSegments("/api") && ctx.Response.StatusCode == 200)
{
ctx.Response.StatusCode = 401;
}
return(Task.CompletedTask);
};
options.Events.OnRedirectToAccessDenied = (ctx) =>
{
if (ctx.Request.Path.StartsWithSegments("/api") && ctx.Response.StatusCode == 200)
{
ctx.Response.StatusCode = 403;
}
return(Task.CompletedTask);
};
});
services.AddMvc(options =>
{
options.Filters.Add(typeof(ValidateModelAttribute));
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "System API", Version = "v1"
});
c.AddSecurityDefinition("Bearer",
new ApiKeyScheme
{
In = "header",
Description = "Please insert JWT with Bearer into field",
Name = "Authorization",
Type = "bearer"
});
});
services.AddAutoMapper();
services.AddScoped <IEmailSender>(_ => new AuthMessageSender(Configuration["EmailSettings:FromAddress"],
Configuration["EmailSettings:Password"],
Configuration["EmailSettings:EmailServer"]));
}
