public static void ConfigureMongoDbIdentity(IServiceCollection services)
{
var serviceProvider = services.BuildServiceProvider();
var ressourceDatabaseSettingsService = serviceProvider.GetService <IRessourceDatabaseSettings>();
var mongoDbIdentityConfiguration = new MongoDbIdentityConfiguration
{
MongoDbSettings = new MongoDbSettings
{
ConnectionString = ressourceDatabaseSettingsService.ConnectionString,
DatabaseName = ressourceDatabaseSettingsService.DatabaseName
},
IdentityOptionsAction = options =>
{
options.Password.RequiredLength = 6;
options.Password.RequireLowercase = true;
options.Password.RequireUppercase = true;
options.Password.RequireNonAlphanumeric = true;
options.Password.RequireDigit = true;
// Lockout settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
options.Lockout.MaxFailedAccessAttempts = 10;
// ApplicationUser settings
options.User.RequireUniqueEmail = true;
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@.-_";
}
};
services.ConfigureMongoDbIdentity <ApplicationUser, ApplicationRole, Guid>(mongoDbIdentityConfiguration);
}
private MongoDbIdentityConfiguration ConfigureIdentity()
{
_logger.LogInformation("Configuring identity");
MongoDbIdentityConfiguration configuration = new MongoDbIdentityConfiguration();
if (Environment.IsEnvironment(EnviromentDevVS))
{
configuration.MongoDbSettings = new MongoDbSettings
{
ConnectionString = _runner.ConnectionString + _swapifyDbSettings.DatabaseName,
DatabaseName = _swapifyDbSettings.DatabaseName
};
}
else
{
configuration.MongoDbSettings = new MongoDbSettings
{
ConnectionString = _swapifyDbSettings.ConnectionString + _swapifyDbSettings.DatabaseName,
DatabaseName = _swapifyDbSettings.DatabaseName
};
}
configuration.IdentityOptionsAction = options =>
{
options.Password.RequireDigit = (bool)_identitySettings.RequireDigit;
options.Password.RequiredLength = (int)_identitySettings.RequiredLength;
options.Password.RequireNonAlphanumeric = (bool)_identitySettings.RequireNonAlphanumeric;
options.Password.RequireUppercase = (bool)_identitySettings.RequireUppercase;
options.Password.RequireLowercase = (bool)_identitySettings.RequireLowercase;
options.SignIn.RequireConfirmedEmail = (bool)_identitySettings.RequireConfirmedEmail;
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes((int)_identitySettings.DefaultLockoutTimeSpan);
options.Lockout.MaxFailedAccessAttempts = (int)_identitySettings.MaxFailedAccessAttempts;
options.User.RequireUniqueEmail = (bool)_identitySettings.RequireUniqueEmail;
};
return(configuration);
}
public static void AddMongoIdentity(this IServiceCollection services, IConfiguration configuration)
{
var mongoDbIdentityConfiguration = new MongoDbIdentityConfiguration
{
MongoDbSettings = new MongoDbSettings
{
ConnectionString = configuration.GetConnectionString("FurnyDb"),
DatabaseName = "FurnyDb"
},
IdentityOptionsAction = options =>
{
options.Password.RequireDigit = false;
options.Password.RequiredLength = 6;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
options.Lockout.MaxFailedAccessAttempts = 10;
options.User.RequireUniqueEmail = true;
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@.-_";
}
};
services.ConfigureMongoDbIdentity <ApplicationUser, ApplicationRole, ObjectId>(mongoDbIdentityConfiguration);
}
/// <summary>
/// Configures the MongoDb Identity store adapters for the types of TUser only from <see cref="MongoIdentityUser{TKey}"/>.
/// </summary>
/// <typeparam name="TUser">The type representing a user.</typeparam>
/// <typeparam name="TKey">The type of the primary key of the identity document.</typeparam>
/// <param name="services">The collection of service descriptors.</param>
/// <param name="mongoDbIdentityConfiguration">A configuration object of the AspNetCore.Identity.MongoDbCore package.</param>
public static void ConfigureMongoDbIdentityUserOnly <TUser, TKey>(
this IServiceCollection services,
MongoDbIdentityConfiguration mongoDbIdentityConfiguration)
where TUser : MongoIdentityUser <TKey>, new()
where TKey : IEquatable <TKey>
{
ValidateMongoDbSettings(mongoDbIdentityConfiguration.MongoDbSettings);
CommonMongoDbSetup <TUser, MongoIdentityRole <TKey>, TKey>(services, mongoDbIdentityConfiguration);
}
// 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 mongoSettings = Configuration.GetSection(nameof(MongoDbSettings));
var settings = Configuration.GetSection(nameof(MongoDbSettings)).Get <MongoDbSettings>();
var mongoDbIdentityConfiguration = new MongoDbIdentityConfiguration
{
MongoDbSettings = settings,
IdentityOptionsAction = options =>
{
options.Password.RequireDigit = false;
options.Password.RequiredLength = 6;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
// Lockout settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
options.Lockout.MaxFailedAccessAttempts = 10;
// ApplicationUser settings
options.User.RequireUniqueEmail = true;
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@.-_";
}
};
services.ConfigureMongoDbIdentity <ApplicationUser, ApplicationRole, Guid>(mongoDbIdentityConfiguration);
services.AddSingleton <MongoDbSettings>(settings);
//services.AddIdentity<ApplicationUser, MongoIdentityRole>()
// .AddMongoDbStores<ApplicationUser, MongoIdentityRole, Guid>(settings.ConnectionString, settings.DatabaseName)
// .AddDefaultTokenProviders();
services.AddTransient <IMongoContext, MongoContext>();
services.AddScoped <BookService>();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
}
static Container()
{
var builder = new ConfigurationBuilder()
.SetBasePath(System.Environment.CurrentDirectory)
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
//per user config that is not committed to repo, use this to override settings (e.g. connection string) based on your local environment.
.AddJsonFile($"appsettings.local.json", optional: true);
builder.AddEnvironmentVariables();
Configuration = builder.Build();
var databaseSettings = Configuration.Load <MongoDbSettings>("MongoDbSettings");
MongoDbIdentityConfiguration = new MongoDbIdentityConfiguration()
{
MongoDbSettings = databaseSettings,
IdentityOptionsAction = (options) =>
{
options.Password.RequireDigit = false;
options.Password.RequireLowercase = false;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.User.AllowedUserNameCharacters = null;
}
};
lock (Locks.MongoInitLock)
{
_mongoDbRepository = new MongoRepository(
databaseSettings.ConnectionString,
databaseSettings.DatabaseName);
_mongoDbRepository2 = new MongoRepository(
databaseSettings.ConnectionString,
databaseSettings.DatabaseName);
}
}
/// <summary>
/// Configures the MongoDb Identity store adapters for the types of TUser and TRole.
/// </summary>
/// <typeparam name="TUser">The type representing a user.</typeparam>
/// <typeparam name="TRole">The type representing a role.</typeparam>
/// <typeparam name="TKey">The type of the primary key of the identity document.</typeparam>
/// <param name="services">The collection of service descriptors.</param>
/// <param name="mongoDbIdentityConfiguration">A configuration object of the AspNetCore.Identity.MongoDbCore package.</param>
/// <param name="mongoDbContext">An object representing a MongoDb connection.</param>
public static IdentityBuilder ConfigureMongoDbIdentity <TUser, TRole, TKey>(this IServiceCollection services, MongoDbIdentityConfiguration mongoDbIdentityConfiguration,
IMongoDbContext mongoDbContext = null)
where TUser : MongoIdentityUser <TKey>, new()
where TRole : MongoIdentityRole <TKey>, new()
where TKey : IEquatable <TKey>
{
IdentityBuilder builder;
ValidateMongoDbSettings(mongoDbIdentityConfiguration.MongoDbSettings);
if (mongoDbContext == null)
{
builder = services.AddIdentityCore <TUser>()
.AddRoles <TRole>()
.AddMongoDbStores <TUser, TRole, TKey>(
mongoDbIdentityConfiguration.MongoDbSettings.ConnectionString,
mongoDbIdentityConfiguration.MongoDbSettings.DatabaseName);
}
else
{
builder = services.AddIdentityCore <TUser>()
.AddRoles <TRole>()
.AddMongoDbStores <IMongoDbContext>(mongoDbContext);
}
if (mongoDbIdentityConfiguration.IdentityOptionsAction != null)
{
services.Configure(mongoDbIdentityConfiguration.IdentityOptionsAction);
}
return(builder);
}
/// <summary>
/// Configures the MongoDb Identity store adapters for the types of TUser only inheriting from <see cref="MongoIdentityUser"/>.
/// </summary>
/// <typeparam name="TUser">The type representing a user.</typeparam>
/// <param name="services">The collection of service descriptors.</param>
/// <param name="mongoDbIdentityConfiguration">A configuration object of the AspNetCore.Identity.MongoDbCore package.</param>
public static IdentityBuilder ConfigureMongoDbIdentity <TUser>(this IServiceCollection services, MongoDbIdentityConfiguration mongoDbIdentityConfiguration)
where TUser : MongoIdentityUser, new()
{
ValidateMongoDbSettings(mongoDbIdentityConfiguration.MongoDbSettings);
return(CommonMongoDbSetup <TUser, MongoIdentityRole, Guid>(services, mongoDbIdentityConfiguration));
}
private static IdentityBuilder CommonMongoDbSetup <TUser, TRole, TKey>(this IServiceCollection services, MongoDbIdentityConfiguration mongoDbIdentityConfiguration)
where TUser : MongoIdentityUser <TKey>, new()
where TRole : MongoIdentityRole <TKey>, new()
where TKey : IEquatable <TKey>
{
IdentityBuilder builder;
builder = services.AddIdentityCore <TUser>()
.AddRoles <TRole>()
.AddMongoDbStores <TUser, TRole, TKey>(
mongoDbIdentityConfiguration.MongoDbSettings.ConnectionString,
mongoDbIdentityConfiguration.MongoDbSettings.DatabaseName);
if (mongoDbIdentityConfiguration.IdentityOptionsAction != null)
{
services.Configure(mongoDbIdentityConfiguration.IdentityOptionsAction);
}
return(builder);
}
/// <summary>
/// Configures the MongoDb Identity store adapters for the types of TUser and TRole.
/// </summary>
/// <typeparam name="TUser">The type representing a user.</typeparam>
/// <typeparam name="TRole">The type representing a role.</typeparam>
/// <typeparam name="TKey">The type of the primary key of the identity document.</typeparam>
/// <param name="services">The collection of service descriptors.</param>
/// <param name="mongoDbIdentityConfiguration">A configuration object of the AspNetCore.Identity.MongoDbCore package.</param>
/// <param name="mongoDbContext">An object representing a MongoDb connection.</param>
public static void ConfigureMongoDbIdentity <TUser, TRole, TKey>(this IServiceCollection services, MongoDbIdentityConfiguration mongoDbIdentityConfiguration,
IMongoDbContext mongoDbContext = null)
where TUser : MongoIdentityUser <TKey>, new()
where TRole : MongoIdentityRole <TKey>, new()
where TKey : IEquatable <TKey>
{
ValidateMongoDbSettings(mongoDbIdentityConfiguration.MongoDbSettings);
if (mongoDbContext == null)
{
services.AddIdentity <TUser, TRole>()
.AddMongoDbStores <TUser, TRole, TKey>(
mongoDbIdentityConfiguration.MongoDbSettings.ConnectionString,
mongoDbIdentityConfiguration.MongoDbSettings.DatabaseName)
.AddDefaultTokenProviders();
}
else
{
services.AddIdentity <TUser, TRole>()
.AddMongoDbStores <IMongoDbContext>(mongoDbContext)
.AddDefaultTokenProviders();
}
if (mongoDbIdentityConfiguration.IdentityOptionsAction != null)
{
services.Configure(mongoDbIdentityConfiguration.IdentityOptionsAction);
}
}
private static void CommonMongoDbSetup <TUser, TRole, TKey>(this IServiceCollection services, MongoDbIdentityConfiguration mongoDbIdentityConfiguration)
where TUser : MongoIdentityUser <TKey>, new()
where TRole : MongoIdentityRole <TKey>, new()
where TKey : IEquatable <TKey>
{
services.AddIdentity <TUser, TRole>()
.AddMongoDbStores <TUser, TRole, TKey>(
mongoDbIdentityConfiguration.MongoDbSettings.ConnectionString,
mongoDbIdentityConfiguration.MongoDbSettings.DatabaseName)
.AddDefaultTokenProviders();
if (mongoDbIdentityConfiguration.IdentityOptionsAction != null)
{
services.Configure(mongoDbIdentityConfiguration.IdentityOptionsAction);
}
}
// 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)
{
var mongoConnectionString = Configuration.GetConnectionString("MongoServer");
var mongoDatabase = Configuration.GetConnectionString("MongoDatabase");
var mongoDbIdentityConfiguration = new MongoDbIdentityConfiguration
{
MongoDbSettings = new MongoDbSettings
{
ConnectionString = mongoConnectionString,
DatabaseName = mongoDatabase
},
IdentityOptionsAction = options =>
{
// password requirements
options.Password.RequireDigit = true;
options.Password.RequiredLength = 8;
options.Password.RequireNonAlphanumeric = true;
options.Password.RequireUppercase = true;
options.Password.RequireLowercase = true;
// lockout settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(15);
options.Lockout.MaxFailedAccessAttempts = 5;
// ApplicationUser settings
options.User.RequireUniqueEmail = true;
options.User.AllowedUserNameCharacters =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
// SignIn requirements
options.SignIn.RequireConfirmedAccount = true;
}
};
services.ConfigureMongoDbIdentity <ApplicationUser, ApplicationRole, Guid>(mongoDbIdentityConfiguration);
//services.AddAuthentication()
// .AddIdentityServerJwt();
//services.AddDbContext<ApplicationFilippSystemDbContext>(options =>
// options.UseSqlite(
// Configuration.GetConnectionString("DefaultConnection")));
//services.AddDefaultIdentity<ApplicationUser>(options => options.SignIn.RequireConfirmedAccount = true)
// .AddEntityFrameworkStores<ApplicationFilippSystemDbContext>();
//services.AddIdentityServer()
// .AddApiAuthorization<ApplicationUser, ApplicationFilippSystemDbContext>();
//services.AddDbContextFactory<FilippSystemContext>(opt =>
// opt.UseSqlite(Configuration.GetConnectionString(FilippSystemContext.BlazorFilippSystemDb))
// .EnableSensitiveDataLogging());
//add the repository
//services.AddScoped<IDbContextFactory<FilippSystemContext>, DbContextFactory<FilippSystemContext>>();
//services.AddScoped<IRepository<Calculation, FilippSystemContext>, CalculationRepository>();
//services.AddScoped<IBasicRepository<Calculation>>(sp =>
// sp.GetService<IRepository<Calculation, FilippSystemContext>>());
//services.AddScoped<IUnitOfWork<Calculation>, UnitOfWork<FilippSystemContext, Calculation>>();
// seeding the first time
//services.AddScoped<EmployeeSeed>();
services.AddControllersWithViews();
services.AddRazorPages();
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
// if (this._loggerFactory == null)
//this._loggerFactory = (ILoggerFactory) new LoggerFactory();
//var cors = new DefaultCorsPolicyService(_loggerFactory.CreateLogger<DefaultCorsPolicyService>())
//{
// AllowedOrigins = { "https://*.infusync.com" },
// AllowAll = true
//};
//services.AddSingleton<ICorsPolicyService>(cors);
// options.AddPolicy("MyCorsPolicy",
// builder => builder
// .SetIsOriginAllowedToAllowWildcardSubdomains()
// .WithOrigins("https://*.infusync.com")
// .AllowAnyMethod()
// .AllowCredentials()
// .AllowAnyHeader()
// .Build()
// );
var dbConf = new MongoDBConfiguration();
if (Environment.IsDevelopment())
{
dbConf.ConnectionString = Configuration["MongoDB:LocalConnectionString"];
dbConf.DatabaseName = Configuration["MongoDB:DatabaseName"];
}
else
{
dbConf.ConnectionString = Configuration["MongoDB:ConnectionString"];
dbConf.DatabaseName = Configuration["MongoDB:DatabaseName"];
}
services.Configure <MongoDBConfiguration>(options =>
{
options.DatabaseName = dbConf.DatabaseName;
options.ConnectionString = dbConf.ConnectionString;
});
//services.AddIdentity<ApplicationUser, IdentityRole>()
// .AddEntityFrameworkStores<ApplicationDbContext>()
// .AddDefaultTokenProviders();
services.AddScoped <IPasswordHasher <ApplicationUser>, BCryptPasswordHasher <ApplicationUser> >();
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.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddIdentity <ApplicationUser, ApplicationRole>()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
var mongoDbIdentityConfiguration = new MongoDbIdentityConfiguration
{
MongoDbSettings = new MongoDbSettings
{
ConnectionString = dbConf.ConnectionString,
DatabaseName = dbConf.DatabaseName
},
IdentityOptionsAction = options =>
{
options.Password.RequireDigit = false;
options.Password.RequiredLength = 8;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
// Lockout settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(30);
options.Lockout.MaxFailedAccessAttempts = 10;
// ApplicationUser settings
options.User.RequireUniqueEmail = true;
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@.-_";
}
};
// Add Multi-Tenancy services.
services.AddMultiTenancy <ApplicationTenant, ObjectId>()
.AddRequestParsers(parsers =>
{
// To test a domain parser locally, add a similar line
// to your hosts file for each tenant you want to test
// For Windows: C:\Windows\System32\drivers\etc\hosts
// 127.0.0.1 tenant1.tenants.local
//parsers.AddSubdomainParser(".tenants.local");
parsers.AddChildPathParser("/tenants/");
});
services.ConfigureMongoDbIdentity <ApplicationUser, ApplicationRole, ObjectId>(mongoDbIdentityConfiguration);
services.AddScoped <ApplicationDbContext>();
services.AddScoped <ApplicationTenant>();
services.AddScoped <ApplicationUser>();
services.AddScoped <ApplicationRole>();
services.AddScoped <IApplicationUserDbContext, ApplicationUserDbContext>();
services.Configure <IISOptions>(iis =>
{
iis.AuthenticationDisplayName = "Windows";
iis.AutomaticAuthentication = false;
});
services.AddTransient <IEmailSender, EmailSender>();
services.Configure <DataProtectionTokenProviderOptions>(options =>
{
options.TokenLifespan = TimeSpan.FromHours(72);
});
//services.AddTransient<IConfigurationDbContext, ConfigurationDbContext>();
//services.AddTransient<IInitConfigFiles, InitConfigFiles>();
var builder = services.AddIdentityServer()
//.AddSigningCredential(cert)
//.AddConfigurationStore(Configuration)
//.AddOperationalStore(Configuration)
//.AddAspNetIdentity<ApplicationUser>()
.AddProfileService <ProfileService>();
if (Environment.IsDevelopment())
{
builder.AddDeveloperSigningCredential();
}
else
{
X509Certificate2 cert = null;
using (X509Store certStore = new X509Store(StoreName.My, StoreLocation.CurrentUser))
{
certStore.Open(OpenFlags.ReadOnly);
X509Certificate2Collection certCollection = certStore.Certificates.Find(
X509FindType.FindByThumbprint,
Configuration["Certificate:thumbprint"],
false);
// Get the first cert with the thumbprint
if (certCollection.Count > 0)
{
cert = certCollection[0];
Log.Logger.Information($"Successfully loaded cert from registry: {cert.Thumbprint}");
}
}
if (cert == null)
{
cert = new X509Certificate2(Path.Combine(Environment.ContentRootPath, "a29c9cfbbc021387f22e906e9f22aeb.pfx"), "infusync");
Log.Logger.Information($"Falling back to cert from file. Successfully loaded: {cert.Thumbprint}");
}
builder.AddSigningCredential(cert);
}
services.AddAuthentication();
//.AddGoogle(options =>
//{
// options.ClientId = "708996912208-9m4dkjb5hscn7cjrn5u0r4tbgkbj1fko.apps.googleusercontent.com";
// options.ClientSecret = "wdfPY6t8H8cecgjlxud__4Gh";
//});
services.AddHangfire(x => x.UseMongoStorage(dbConf.ConnectionString, dbConf.DatabaseName));
var cbuilder = new ContainerBuilder();
cbuilder.RegisterType(typeof(ODDbContext))
.As(typeof(IODDbContext))
.InstancePerLifetimeScope();
cbuilder.RegisterType(typeof(InitConfigFiles))
.As(typeof(IInitConfigFiles))
.InstancePerLifetimeScope();
cbuilder.RegisterType(typeof(ConfigurationDbContext))
.As(typeof(IConfigurationDbContext))
.InstancePerLifetimeScope();
cbuilder.RegisterGeneric(typeof(Repository <>))
.As(typeof(IRepository <>))
.InstancePerLifetimeScope();
cbuilder.Populate(services);
ApplicationContainer = cbuilder.Build();
//GlobalConfiguration.Configuration.UseAutofacActivator(ApplicationContainer, false);
return(new AutofacServiceProvider(ApplicationContainer));
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure <MovieAppDBSettings>(
Configuration.GetSection(nameof(MovieAppDBSettings)));
services.AddSingleton <IMovieAppDBSettings>(sp =>
sp.GetRequiredService <IOptions <MovieAppDBSettings> >().Value);
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(
Configuration.GetConnectionString("DefaultConnection")));
//services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
// .AddEntityFrameworkStores<ApplicationDbContext>();
//services.AddIdentity<User, Role>()
// .AddMongoDbStores<User, Role, ObjectId>
// (
// "mongodb+srv://pdesic17:[email protected]/test?retryWrites=true&w=majority",
// "MovieAppDB"
// )
// .AddDefaultTokenProviders();
var mongoDbIdentityConfiguration = new MongoDbIdentityConfiguration
{
MongoDbSettings = new MongoDbSettings
{
ConnectionString = "mongodb+srv://pdesic17:[email protected]/test?retryWrites=true&w=majority",
DatabaseName = "MovieAppDB"
},
IdentityOptionsAction = options =>
{
options.Password.RequireDigit = false;
options.Password.RequiredLength = 6;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
// ApplicationUser settings
options.User.RequireUniqueEmail = true;
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@.-_";
}
};
services.ConfigureMongoDbIdentity <User, Role, ObjectId>(mongoDbIdentityConfiguration);
services.AddControllersWithViews();
services.AddRazorPages();
services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
{
builder.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader();
}));
services.AddSingleton <MovieService>();
services.AddSingleton <GenreService>();
services.AddSingleton <UserService>();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var mongoDbIdentityConfiguration = new MongoDbIdentityConfiguration
{
MongoDbSettings = new AspNetCore.Identity.MongoDbCore.Infrastructure.MongoDbSettings
{
ConnectionString = "mongodb://*****:*****@.-_";
}
};
services.Configure <Data.Repository.Settings.MongoDbSettings>(Configuration.GetSection("MongoDbSettings"));
services.AddSingleton <IMongoDbSettings>(serviceProvider =>
(IMongoDbSettings)serviceProvider.GetRequiredService <IOptions <Data.Repository.Settings.MongoDbSettings> >().Value);
// services.AddIdentity<ApplicationUser, ApplicationRole>()
// .AddMongoDbStores<ApplicationUser, ApplicationRole, Guid>("mongodb://localhost:27017", "MongoDbTests")
// .AddDefaultTokenProviders();
services.ConfigureMongoDbIdentity <ApplicationUser, ApplicationRole, Guid>(mongoDbIdentityConfiguration);
services.AddScoped(typeof(IMongoRepository <>), typeof(MongoRepository <>));
services.AddScoped(typeof(Neo4jRepository <>));
services.AddScoped <UserManagerService>();
services.AddScoped <JwtService>();
services.AddScoped <PostService>();
services.AddScoped <LikeService>();
services.AddScoped <CommentService>();
services.AddScoped <FollowerService>();
services.AddControllers().AddNewtonsoftJson(options => options.UseMemberCasing());
services.AddAutoMapper(AppDomain.CurrentDomain.GetAssemblies());
services.AddCors();
services.AddAuthentication(options =>
{
options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(config =>
{
config.RequireHttpsMetadata = false;
config.SaveToken = true;
config.TokenValidationParameters = new TokenValidationParameters()
{
ValidIssuer = Configuration["Jwt:Issuer"],
ValidAudience = Configuration["Jwt:Audience"],
ValidateLifetime = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration["Jwt:Key"])),
ClockSkew = TimeSpan.Zero
};
});
services.Configure <JwtOptions>(Configuration.GetSection("Jwt"));
services.AddSwaggerGen(options =>
{
options.SwaggerDoc("v2", new Microsoft.OpenApi.Models.OpenApiInfo
{
Title = "Place Info Service API",
Version = "v2",
Description = "Sample service for Learner",
});
});
}
public static void AddMongoDbIdentityConfiguration(this IServiceCollection services, IConfiguration configuration)
{
services.Configure <CookiePolicyOptions>(options =>
{
// Este lambda determina se o consentimento do usuário para cookies não essenciais é necessário para uma determinada solicitação (request).
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = Microsoft.AspNetCore.Http.SameSiteMode.None;
});
//services.ConfigureApplicationCookie(options =>
//{
// options.Events.OnRedirectToLogin = context =>
// {
// context.Response.StatusCode = 401;
// return Task.CompletedTask;
// };
//});
services.Configure <PasswordHasherOptions>(options =>
options.CompatibilityMode = PasswordHasherCompatibilityMode.IdentityV2);
var mongoDbIdentityConfiguration = new MongoDbIdentityConfiguration()
{
MongoDbSettings = new MongoDbSettings
{
ConnectionString = configuration.GetSection("AppMongoSettings:ConnectionString").Value,
DatabaseName = configuration.GetSection("AppMongoSettings:Database").Value
},
IdentityOptionsAction = options =>
{
options.Password.RequireDigit = false;
options.Password.RequiredLength = 4;
options.Password.RequireNonAlphanumeric = false;
options.Password.RequireUppercase = false;
options.Password.RequireLowercase = false;
// Lockout settings
options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
options.Lockout.MaxFailedAccessAttempts = 5;
options.Lockout.AllowedForNewUsers = true;
// ApplicationUser settings - Correçao para validation failed: InvalidUserName
options.User.RequireUniqueEmail = true;
options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+/ ã~";
options.SignIn.RequireConfirmedAccount = true;
options.Tokens.EmailConfirmationTokenProvider = TokenOptions.DefaultProvider;
options.Tokens.AuthenticatorTokenProvider = TokenOptions.DefaultAuthenticatorProvider;
}
};
services.ConfigureMongoDbIdentity <ApplicationUser, ApplicationRole, Guid>(mongoDbIdentityConfiguration);
services.ConfigureApplicationCookie(options =>
{
// Cookie settings - Change email and activity timeout - The default inactivity timeout is 14 days.
options.Cookie.HttpOnly = true;
options.ExpireTimeSpan = TimeSpan.FromMinutes(5);
options.SlidingExpiration = true;
options.LoginPath = "/Identity/Account/Login";
options.LogoutPath = "/Identity/Account/Logout";
options.AccessDeniedPath = "/Identity/Account/AccessDenied";
});
// O código a seguir altera todos os tokens de proteção de dados período de tempo limite para 3 horas
// What we want for our password reset token is to be valid for a limited time,
services.Configure <DataProtectionTokenProviderOptions>(o => o.TokenLifespan = TimeSpan.FromMinutes(10));
}
