// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
//Setup para configuração do Swagger
SwaggerConfiguration.AddSwagger(services);
//Setup para configuração do EntityFramework
EntityFrameworkConfiguration.AddEntityFramework(services, Configuration);
//Setup para configuração do JWT
JwtConfiguration.ConfigureServices(services, Configuration);
//Setup para o MongoDB
MongoDBConfiguration.AddMongoDBSetup(services, Configuration);
//Injeção de dependência
DependencyInjectionConfiguration.AddDependencyInjection(services);
//Setup para o MediatR
MediatRConfiguration.AddMediatRSetup(services);
//Setup para o AutoMapper
AutoMapperConfiguration.AddAutoMapperSetup(services);
//Setup para o CORS
CorsConfiguration.AddCors(services);
}
private static MongoContext CreateNewContext()
{
MongoContext ctx = new MongoContext();
ctx._mongoClient = new MongoClient(MongoDBConfiguration.GetConfig().MongoDBCollection["Connection"].Value);
return(ctx);
}
public static IServiceCollection AddMongoDBIdentity <TUser, TRole>(this IServiceCollection services, IConfiguration configuration) where TUser : IdentityUser where TRole : IdentityRole
{
services.Configure <MongoDBConfiguration>(options => options = new MongoDBConfiguration {
ConnectionString = configuration.GetSection("MongoDB::ConnectionString").Value
});
return(services.AddMongoDBIdentity <TUser, TRole>());
}
protected BaseRepository(MongoDBConfiguration mongoDBConfig)
{
_mongoDBConfig = mongoDBConfig;
var url = new MongoUrl(_mongoDBConfig.DbConnectionString);
var client = new MongoClient(url);
var db = client.GetDatabase(url.DatabaseName);
EntityCollection = db.GetCollection <TEntity>(CollectionName);
}
public OrchestratorService(ILogger <OrchestratorService> logger,
IOptions <MongoDBConfiguration> mongoDbOptions,
IOptions <RabbitMQConfiguration> rabbitMqOptions,
GameStateMachine stateMachine)
{
mongoDbConfig = mongoDbOptions.Value;
rabbitMqConfig = rabbitMqOptions.Value;
this.logger = logger;
this.stateMachine = stateMachine;
}
public UsersRepository(MongoDBConfiguration mongoDBConfig) : base(mongoDBConfig)
{
var userIndexDefinition = Builders <UserEntity> .IndexKeys.Ascending(r => r.Username);
var createIndexOptions = new CreateIndexOptions()
{
Name = "UserUsernameIndexAsc", Background = true, Unique = true
};
EntityCollection.Indexes.CreateOne(userIndexDefinition, createIndexOptions);
}
/// <summary>
/// Initialized a new instance of the class <see cref="MongoDBStorageServiceProvider"/>
/// </summary>
public MongoDBStorageServiceProvider(IConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
_mongoConfig = configuration.GetConfig <MongoDBConfiguration>(MongoDBConfiguration.ConfigurationSectionKey);
_collectionNames = _mongoConfig.CollectionNames.SelectMany(c => c.Value)
.ToImmutableDictionary(k => k, v => _mongoConfig.CollectionNames.First(t => t.Value.Contains(v)).Key);
_mongoClient = new MongoClient($"mongodb://${_mongoConfig.Host}:${_mongoConfig.Port}/${_mongoConfig.DataBase}");
_mongoDB = _mongoClient.GetDatabase(_mongoConfig.DataBase, s_mongoSettings);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
MongoDBConfiguration mongoDBCfg = new MongoDBConfiguration();
Configuration.GetSection("MongoDBConfiguration").Bind(mongoDBCfg);
RedisConfiguration redisCfg = new RedisConfiguration();
Configuration.GetSection("RedisConfiguration").Bind(mongoDBCfg);
ServiceStartUp.StartUpMongoDB(mongoDBCfg);
ServiceStartUp.StartUpRedis(redisCfg);
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app.UseMvc();
}
public static IServiceCollection AddMongoDB(this IServiceCollection services, MongoDBConfiguration mongoConfig)
{
services.AddSingleton(p => new MongoDBService(mongoConfig));
AddCommonServices(services);
return(services);
}
public PollRepository(MongoDBConfiguration _option)
{
_client = new MongoClient(_option.DefaultConnection);
_database = _client.GetDatabase(_option.DatabaseName);
}
public DbContext(IOptions <MongoDBConfiguration> mongoOptions)
{
mongoConfig = mongoOptions.Value;
Client = new MongoClient(mongoConfig.Endpoint);
Database = Client.GetDatabase(mongoConfig.Database);
}
static MongoUrl BuildConnectionString(MongoDBConfiguration configuration)
=> new MongoUrlBuilder(configuration.Host)
{
UseTls = configuration.UseSSL,
DatabaseName = configuration.Database
}.ToMongoUrl();
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));
}
/// <summary>
/// Constructor used by the DI
/// </summary>
/// <param name="mongoClient">The injected interface of the mongo client</param>
/// <param name="optionsMongoDB">The IOptions that contains the mongo configurations</param>
/// <param name="logger">The injected logger</param>
public MongoService(IMongoClient mongoClient, IOptions <MongoDBConfiguration> optionsMongoDB, ILogger <MongoService> logger)
{
this.logger = logger;
mongoDBConfiguration = optionsMongoDB.Value;
this.mongoClient = mongoClient;
}
public NotesRepository(MongoDBConfiguration mongoDBConfig) : base(mongoDBConfig)
{
}
