public MongoGridFsProviderTest()
{
_runner = MongoDbRunner.Start();
_mongoClientSettings = MongoClientSettings.FromConnectionString(_runner.ConnectionString);
_client = new MongoClient(_mongoClientSettings);
_db = _client.GetDatabase("foo");
// Create db and gridfs collections
var bucket = new GridFSBucket(_db);
var createDb = bucket.UploadFromBytes("someData", new byte[1]);
}
public RestaurantDBContext(IOptions <RestaurantDatabaseSettings> options)
{
this._restaurantDatabaseSettings = options.Value;
MongoClientSettings clientSettings = MongoClientSettings.FromConnectionString(_restaurantDatabaseSettings.ConnectionString);
MongoClient client = new MongoClient(clientSettings);
if (client != null)
{
this.database = client.GetDatabase(_restaurantDatabaseSettings.DatabaseName.Trim());
}
//_restaurant = database.GetCollection<Restaurant>(settings.RestaurantCollectionName);
}
public void AddMongoClientWithMongoSettings()
{
var services = CreateServices();
var clientSettings = MongoClientSettings.FromConnectionString("mongodb://localhost");
services.AddMongoClient(clientSettings);
var sp = services.BuildServiceProvider();
var client = sp.GetRequiredService <IMongoClient>();
client.Settings.Server.Should().BeEquivalentTo(
new MongoServerAddress("localhost", 27017));
}
public static IIdentityServerBuilder AddMongoPersistedGrantStore(this IIdentityServerBuilder builder, string connection_string, string database_name)
{
var client = new MongoClient(MongoClientSettings.FromConnectionString(connection_string));
builder.Services.AddDisposableSingleInstanceService(new IdsMongoConnectionWrapper(client, database_name));
builder.Services.AddTransient(typeof(IIdsRepository <>), typeof(IdsRepository <>));
builder.Services.AddTransient <IIdentityServerDatabaseHelper, IdsMongoDatabaseHelper>();
builder.Services.RemoveAll <IPersistedGrantStore>();
builder.AddPersistedGrantStore <MongoPersistedGrantStore>();
return(builder);
}
public CatalogContext(IConfiguration configuration)
{
this.configuration = configuration;
var connectionString = configuration.GetValue <String>("MongoSettings:ConnectionString");
MongoClientSettings settings = MongoClientSettings.FromConnectionString(connectionString);
MongoClient client = new MongoClient(settings);
if (client != null)
{
// database with NAME catalogDb is created
this.database = client.GetDatabase(configuration.GetValue <string>("MongoSettings:Database"));
}
}
public CatalogDbContext(IConfiguration configuration)
{
this.configuration = configuration;
var connectionString = configuration.GetValue <string>("MongoSettings:ConnectionString");
MongoClientSettings mongoClientSetting = MongoClientSettings.FromConnectionString(connectionString);
MongoClient mongoClient = new MongoClient();
if (mongoClient != null)
{
var databaseString = configuration.GetValue <string>("MongoSettings:Database");
this.mongoDatabase = mongoClient.GetDatabase(databaseString);
}
}
private void ConfigureConnections()
{
var connectionString = Configuration.GetConnectionString("stringConexaoBanco");
var configurations = MongoClientSettings.FromConnectionString(connectionString);
configurations.MaxConnectionIdleTime = TimeSpan.FromSeconds(30);
configurations.UseTls = false;
configurations.RetryWrites = false;
var client = new MongoClient(configurations);
MongoConnection = client.GetDatabase(DatabaseName);
}
private void SetDefaultClient()
{
string connectionString = this.mongoConfiguration.ConnectionString;
MongoClientSettings settings = MongoClientSettings.FromConnectionString(connectionString);
if (this.mongoConfiguration.MaxConnectionsPerPool > 0)
{
settings.MaxConnectionPoolSize = this.mongoConfiguration.MaxConnectionsPerPool;
}
this.DefaultClient = new MongoClient(settings);
clientsRepository.Add("default", this.DefaultClient);
}
public static MongoClient getMongoDBClient()
{
try
{
string connectionString = System.Environment.GetEnvironmentVariable("MONGO_URI");
var settings = MongoClientSettings.FromConnectionString(connectionString);
return(new MongoClient(settings));
}
catch (Exception ex)
{
throw new MongoException("It was not possible to connect to MongoDB", ex);
}
}
public MongoContext(IOptions <MongoSettings> options)
{
var mongoClientSettings = MongoClientSettings.FromConnectionString(options.Value.ConnectionString);
Client = new MongoClient(mongoClientSettings);
DatabaseName = options.Value.DatabaseName;
Database = Client.GetDatabase(options.Value.DatabaseName);
_collectionNames = Database.ListCollectionNames().ToList().ToHashSet();
Appointments = GetCreatedCollection <Appointment>("appointments");
}
private static MongoClient CreateMongoClient()
{
MongoClientSettings settings = MongoClientSettings.FromConnectionString($"mongodb://{SettingsProvider.GetMongoDbHost()}:27017");
settings.ClusterConfigurator = (cb) =>
{
cb.Subscribe <CommandStartedEvent>(e =>
{
Trace.WriteLine($"{e.CommandName} - {e.Command.ToJson()}");
});
};
return(new MongoClient(settings));
}
public BookingHistoryService(IOptions <MongoSettings> options)
{
this.mongosettings = options.Value;
MongoClientSettings clientsettings = MongoClientSettings.FromConnectionString(mongosettings.ConnectionString);
MongoClient client = new MongoClient(clientsettings);
if (client != null)
{
this.database = client.GetDatabase(mongosettings.Database.Trim());
}
}
public MongoDbContext(AggregateSettings settings = default, bool destroy = true, IDateTime dateTime = default, string databaseId = default)
{
_databaseId = databaseId ?? "v" + Guid.NewGuid().ToString().Replace("-", "");
_dateTime = dateTime ?? new StaticDateTime();
_destroy = destroy;
var connectionSettings = MongoClientSettings.FromConnectionString("mongodb://localhost:27017");
_client = new MongoClient(connectionSettings);
_database = _client.GetDatabase(_databaseId);
_factory = new AggregateCollectionFactory(_database);
_settings = settings;
_repository = new AggregateRepository <T>(_factory, _dateTime, _settings);
}
static async Task Main(string[] args)
{
var mongoSettings = MongoClientSettings.FromConnectionString(args[0]);
var client = new MongoClient(mongoSettings);
var mongoDatabase = client.GetDatabase("dr-move-public-api");
var bucket = new GridFSBucket(mongoDatabase, new GridFSBucketOptions
{
BucketName = "packages",
});
if (!int.TryParse(args[1], out var numberOfDays))
{
Console.WriteLine($"Could not parse {args[1]} to an int.");
return;
}
if (numberOfDays < 30)
{
Console.WriteLine("Minimum number of days = 30");
return;
}
var mongoFilter =
Builders <GridFSFileInfo <ObjectId> > .Filter.Lt(x => x.UploadDateTime, DateTime.UtcNow.AddDays(-numberOfDays));
var options = new GridFSFindOptions
{
BatchSize = 50,
};
var batchnum = 0;
var numFiles = 0;
using (var cursor = await bucket.FindAsync(mongoFilter, options))
{
while (await cursor.MoveNextAsync())
{
var batch = cursor.Current;
Console.WriteLine($"Deleting from batch {++batchnum}");
foreach (var item in batch)
{
numFiles++;
await bucket.DeleteAsync(item.Id);
}
}
}
Console.WriteLine($"Deleted {numFiles} number of files");
}
/// <summary>
/// Configure the Database context for the database.
/// There is one context per database and collections per context!
/// </summary>
/// <typeparam name="TContext"></typeparam>
/// <param name="services"></param>
/// <param name="configuration"></param>
/// <param name="connectionStringKey"></param>
public static void AddMongoDatabase <TContext>(this IServiceCollection services, IConfiguration configuration, string connectionStringKey) where TContext : DbContext, new()
{
var connectionString = configuration.GetConnectionString(connectionStringKey);
var mongoUrl = new MongoUrl(connectionString);
services.Configure <MongoClientSettings>(mongoUrl.DatabaseName.ToLowerInvariant(), options =>
{
var c = MongoClientSettings.FromConnectionString(configuration.GetConnectionString(connectionStringKey));
options.AllowInsecureTls = c.AllowInsecureTls;
options.ApplicationName = c.ApplicationName;
options.AutoEncryptionOptions = c.AutoEncryptionOptions;
options.ClusterConfigurator = c.ClusterConfigurator;
options.ConnectTimeout = c.ConnectTimeout;
options.Credential = c.Credential;
options.HeartbeatInterval = c.HeartbeatInterval;
options.IPv6 = c.IPv6;
options.LocalThreshold = c.LocalThreshold;
options.MaxConnectionIdleTime = c.MaxConnectionIdleTime;
options.MaxConnectionLifeTime = c.MaxConnectionLifeTime;
options.MaxConnectionPoolSize = c.MaxConnectionPoolSize;
options.MinConnectionPoolSize = c.MinConnectionPoolSize;
options.ReadConcern = c.ReadConcern;
options.ReadEncoding = c.ReadEncoding;
options.ReadPreference = c.ReadPreference;
options.ReplicaSetName = c.ReplicaSetName;
options.RetryReads = c.RetryReads;
options.RetryWrites = c.RetryWrites;
options.Scheme = c.Scheme;
options.SdamLogFilename = c.SdamLogFilename;
options.Server = c.Server;
options.Servers = c.Servers;
options.ServerSelectionTimeout = c.ServerSelectionTimeout;
options.SocketTimeout = c.SocketTimeout;
options.SslSettings = c.SslSettings;
options.UseTls = c.UseTls;
options.WaitQueueTimeout = c.WaitQueueTimeout;
options.WriteConcern = c.WriteConcern;
options.WriteEncoding = c.WriteEncoding;
});
var contextBuilder = new DbContextBuilder(services, mongoUrl.DatabaseName, connectionStringKey);
var dbContext = new TContext();
services.TryAddSingleton(typeof(TContext), (provider) => dbContext);
services.TryAddSingleton(typeof(IMongoClientFactory <TContext>), typeof(DefaultMongoClientFactory <TContext>));
dbContext.Configure(contextBuilder);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <IMongoClient>(sp =>
{
var settings =
MongoClientSettings.FromConnectionString(Configuration.GetValue <string>("MongoConnectionString"));
settings.ClusterConfigurator = builder => builder.Subscribe(new MongoEventSubscriber());
return(new MongoClient(settings));
});
services.AddControllers();
}
private MongoClient CreateClient(string connectionString)
{
void SocketConfigurator(Socket s) => s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
var settings = MongoClientSettings.FromConnectionString(connectionString);
settings.SocketTimeout = TimeSpan.FromSeconds(60);
settings.MaxConnectionIdleTime = TimeSpan.FromSeconds(60);
settings.ClusterConfigurator = builder =>
builder.ConfigureTcp(tcp => tcp.With(socketConfigurator: (Action <Socket>)SocketConfigurator));
var mongoclient = new MongoDB.Driver.MongoClient(settings);
return(mongoclient);
}
public MongoBirdSearch(IBirdSearch birdSearch, TimeSpan expiration, string databaseName)
{
_birdSearch = birdSearch;
Expiration = expiration;
var mongoClientSettings = MongoClientSettings.FromConnectionString("mongodb://localhost");
mongoClientSettings.ServerSelectionTimeout = TimeSpan.FromSeconds(5);
_client = new MongoClient(mongoClientSettings);
_database = _client.GetDatabase(databaseName);
_flights = _database.GetCollection <FlightModel>("flights");
_records = _database.GetCollection <RecordInfo>("records");
}
public MongoRepository(IOptions <MongoDbConfiguration> options)
{
lock (_lock)
{
var settings = MongoClientSettings.FromConnectionString(options.Value.ConnectionString);
settings.ServerSelectionTimeout = TimeSpan.FromMilliseconds(options.Value.ConnectionTimeoutMs);
var mongoClient = new MongoClient(settings);
_database = mongoClient.GetDatabase(options.Value.Database);
var collectionName = typeof(TEntity).Name;
Collection = _database.GetCollection <TEntity>(collectionName);
Options = options;
}
}
public MongoRepository(IOptions <MongoSettings> mongoOption)
{
var mongoSetting = MongoClientSettings.FromConnectionString(mongoOption.Value.ConnectionString);
BsonSerializer.RegisterSerializer(new GuidSerializer(GuidRepresentation.Standard));
#pragma warning disable CS0618
// Required since guid representation is not respected in filter definition https://jira.mongodb.org/projects/CSHARP/issues/CSHARP-3179?filter=allopenissues
// Thread explaining work around: https://www.mongodb.com/community/forums/t/c-driver-2-11-1-allegedly-use-different-guid-representation-for-insert-and-for-find/8536/3
BsonDefaults.GuidRepresentationMode = GuidRepresentationMode.V3;
#pragma warning restore CS0618
var client = new MongoClient(mongoSetting);
this._database = client.GetDatabase(mongoOption.Value.DatabaseName);
}
/// <summary>
/// Temporary patch until SERVER-39704 is resolved.
/// </summary>
public void PrimeShardRoutersWithDistinctCommand()
{
var connectionString = CoreTestConfiguration.ConnectionStringWithMultipleShardRouters;
foreach (var endPoint in connectionString.Hosts.Cast <DnsEndPoint>())
{
var clientSettings = MongoClientSettings.FromConnectionString(connectionString.ToString());
clientSettings.Server = new MongoServerAddress(endPoint.Host, endPoint.Port);
var client = new MongoClient(clientSettings);
var database = client.GetDatabase(_databaseName);
var collection = database.GetCollection <BsonDocument>(_collectionName);
collection.Distinct <BsonValue>("_id", "{ }");
}
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers()
.ConfigureApiBehaviorOptions(opts => {
opts.SuppressModelStateInvalidFilter = true;
opts.SuppressMapClientErrors = true;
});
services.AddSwaggerGen(c => c.SwaggerDoc("v1", new OpenApiInfo {
Title = "InvestmentReporting.ImportService", Version = "v1"
}));
services.AddSharedAuthentication();
services.AddMemoryCache();
services.AddSingleton <IMongoDatabase>(_ => {
var mongoSettings = MongoClientSettings.FromConnectionString(MongoConnectionString.Create());
var client = new MongoClient(mongoSettings);
return(client.GetDatabase("InvestmentReporting"));
});
services.AddSingleton <IIdGenerator, ObjectIdGenerator>();
services.AddSingleton <IStateRepository, MongoStateRepository>();
services.AddSingleton <CurrencyConfiguration>();
services.AddSingleton <StateManager>();
services.AddScoped <TransactionStateManager>();
services.AddScoped <IStateManager>(sp => sp.GetRequiredService <TransactionStateManager>());
services.AddScoped(sp => {
var factory = new ImportUseCaseFactory(t => (IImportUseCase)sp.GetRequiredService(t));
factory.Register <AlphaDirectImportUseCase>("AlphaDirectMyBroker");
factory.Register <TinkoffImportUseCase>("TinkoffBrokerReport");
return(factory);
});
services.AddScoped <AlphaDirectImportUseCase>();
services.AddScoped <AlphaBrokerMoneyMoveParser>();
services.AddScoped <AlphaTradeParser>();
services.AddScoped <TinkoffImportUseCase>();
services.AddScoped <TinkoffBrokerMoneyMoveParser>();
services.AddScoped <AssetParser>();
services.AddScoped <TinkoffTradeParser>();
services.AddScoped <AlphaDirectCouponParser>();
services.AddScoped <TinkoffCouponParser>();
services.AddScoped <DividendParser>();
services.AddScoped <AssetMoveParser>();
services.AddScoped <SplitDetector>();
services.AddScoped <TransferParser>();
services.AddScoped <AddIncomeUseCase>();
services.AddScoped <AddExpenseUseCase>();
services.AddScoped <BuyAssetUseCase>();
services.AddScoped <SellAssetUseCase>();
services.AddScoped <ReduceAssetUseCase>();
services.AddSingleton <BackgroundImportService>();
}
public MongoDB(IConfiguration configuration)
{
try
{
var settings = MongoClientSettings.FromConnectionString(configuration["ConnectionString"]);
var client = new MongoClient(settings);
DB = client.GetDatabase(configuration["NomeBD"]);
MapClasses();
}
catch (Exception e)
{
throw new MongoException("It was not possible to connect to MongoDB", e);
}
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.AddSwaggerGen(c => { c.SwaggerDoc("v1", new OpenApiInfo {
Title = "WebApi", Version = "v1"
}); });
services.AddTransient <ExampleJob>();
var connectionString = Configuration.GetValue <string>("Mongo:ConnectionString");
var dbName = Configuration.GetValue <string>("Mongo:DbName");
var mongoClientSettings = MongoClientSettings.FromConnectionString(connectionString);
services.AddHangfire(c =>
{
c.UseMongoStorage(mongoClientSettings, dbName, new MongoStorageOptions
{
MigrationOptions = new MongoMigrationOptions
{
MigrationStrategy = new MigrateMongoMigrationStrategy(),
BackupStrategy = new CollectionMongoBackupStrategy()
}
});
c.UseOpenTracingFilter();
});
services.AddHangfireServer();
services.AddSingleton <ITracer>(sp =>
{
var loggerFactory = sp.GetRequiredService <ILoggerFactory>();
var serviceName = sp.GetRequiredService <IWebHostEnvironment>().ApplicationName;
var reporter = new RemoteReporter.Builder()
.WithLoggerFactory(loggerFactory)
.WithSender(new UdpSender(string.Empty, 6831, 0))
.Build();
var tracer = new Tracer.Builder(serviceName)
.WithLoggerFactory(loggerFactory)
.WithSampler(new ConstSampler(true))
.WithReporter(reporter)
.Build();
GlobalTracer.Register(tracer);
return(tracer);
});
}
public void CamelCaseConvention_HangfireMongoDtos_StillInPascal()
{
// ARRANGE
var mongoStorage = new MongoStorage(
MongoClientSettings.FromConnectionString(ConnectionUtils.GetConnectionString()),
ConnectionUtils.GetDatabaseName(), new MongoStorageOptions
{
MigrationOptions = new MongoMigrationOptions
{
Strategy = MongoMigrationStrategy.Drop,
BackupStrategy = MongoBackupStrategy.None
}
}
);
var id = Guid.NewGuid();
var dbContext = ConnectionUtils.CreateDbContext();
JobStorage.Current = mongoStorage;
bool jobScheduled;
var conventionPack = new ConventionPack {
new CamelCaseElementNameConvention()
};
ConventionRegistry.Register("CamelCase", conventionPack, t => true);
// ACT
using (new BackgroundJobServer(new BackgroundJobServerOptions
{
SchedulePollingInterval = TimeSpan.FromMilliseconds(100)
}))
{
BackgroundJob.Enqueue(() => Signal.Set(id));
jobScheduled = Signal.WaitOne(id, TimeSpan.FromSeconds(1));
}
// ASSERT
var jobGraphCollectionName = dbContext.JobGraph.CollectionNamespace.CollectionName;
var jobDto = dbContext
.Database
.GetCollection <BsonDocument>(jobGraphCollectionName)
.Find(new BsonDocument("expireAt", new BsonDocument("$exists", true)))
.FirstOrDefault();
Assert.Null(jobDto);
Assert.True(jobScheduled, "Expected job to be scheduled");
}
public async Task InitializeAsync(GameRepositorySettings settings)
{
var mongoClientSettings = MongoClientSettings.FromConnectionString(settings.ConnectionString);
mongoClientSettings.SslSettings = new SslSettings()
{
EnabledSslProtocols = SslProtocols.Tls12
};
mongoClientSettings.ClusterConfigurator = builder =>
{
//builder.Subscribe(new SingleEventSubscriber<CommandSucceededEvent>(CommandSucceededEventHandler));
//builder.Subscribe(new SingleEventSubscriber<CommandStartedEvent>(CommandStartedEventHandler));
};
mongoClientSettings.ConnectTimeout = TimeSpan.FromSeconds(5);
mongoClientSettings.ServerSelectionTimeout = TimeSpan.FromSeconds(5);
var client = new MongoClient(mongoClientSettings);
var db = client.GetDatabase(settings.Database);
_reservationCollection = db.GetCollection <Reservation>(Constants.ReservationCollection);
await _reservationCollection.Indexes.CreateOneAsync(
new CreateIndexModel <Reservation>(Builders <Reservation> .IndexKeys.Ascending(reservation => reservation.Player.PlayerId)));
_gameStateCollection = db.GetCollection <GameState>(Constants.GameStateCollection);
await _gameStateCollection.Indexes.CreateManyAsync(new[]
{
new CreateIndexModel <GameState>(Builders <GameState> .IndexKeys.Ascending(state => state.Player1State.Player.PlayerId)),
new CreateIndexModel <GameState>(Builders <GameState> .IndexKeys.Ascending(state => state.Player2State.Player.PlayerId))
});
if (!Directory.Exists(settings.InitialSetupsFolderPath))
{
throw new DirectoryNotFoundException($"Folder {settings.InitialSetupsFolderPath} does not exist.");
}
var initialSetups = new List <InitialSetup>();
foreach (var layoutFilePath in Directory.EnumerateFiles(settings.InitialSetupsFolderPath, "*.json"))
{
try
{
initialSetups.Add(JsonConvert.DeserializeObject <InitialSetup>(File.ReadAllText(layoutFilePath)));
}
catch (Exception e)
{
Logger.Warn(e);
}
}
_initialSetups = initialSetups.AsReadOnly();
}
/// <summary>
/// Configure Hangfire to use MongoDB storage
/// </summary>
/// <param name="configuration">Configuration</param>
/// <param name="connectionString">Connection string for Mongo database, for example 'mongodb://*****:*****@host:port/database'</param>
/// <param name="storageOptions">Storage options</param>
/// <exception cref="ArgumentException">Thrown if the connection string does not include the database name</exception>
/// <returns></returns>
public static MongoStorage UseMongoStorage(this IGlobalConfiguration configuration,
string connectionString,
MongoStorageOptions storageOptions)
{
var mongoUrlBuilder = new MongoUrlBuilder(connectionString);
var databaseName = mongoUrlBuilder.DatabaseName;
if (string.IsNullOrEmpty(databaseName))
{
throw new ArgumentException("The connection string must include the database name, see https://docs.mongodb.com/manual/reference/connection-string/", nameof(connectionString));
}
var mongoClientSettings = MongoClientSettings.FromConnectionString(connectionString);
return(UseMongoStorage(configuration, mongoClientSettings, databaseName, storageOptions));
}
public BaseTestContext()
{
new DB(MongoClientSettings.FromConnectionString(
"mongodb://*****:*****@localhost:27025/"),
"test");
ClearUsers();
ClearTeams();
ClearPages();
ClearAttachments();
UserModel.CreateIndices();
TeamModel.CreateIndices();
PageModel.CreateIndices();
}
public Mocks(bool createTelemetry = true, MongoApplicationInsightsSettings settings = null)
{
StubTelemetry = new StubTelemetry();
if (createTelemetry)
{
var mongoClientSettings = MongoClientSettings.FromConnectionString(
"mongodb://localhost:27017/");
Telemetry = new MongoApplicationInsightsTelemetry(
mongoClientSettings,
TelemetryClient,
settings ?? new MongoApplicationInsightsSettings());
}
}
// TODO Add MongoDb settings in appsettings
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
#region Swagger Configurations
var assemblyPath = typeof(Startup).Assembly.Location;
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1",
new OpenApiInfo
{
Title = "Sample Api MongoDB v1",
Version = "v1",
Description = "Sample Api MongoDB v1"
});
c.ExampleFilters();
c.MapType <Guid>(() => new OpenApiSchema {
Type = "string", Format = "uuid"
});
c.UseInlineDefinitionsForEnums();
c.IncludeXmlComments($"{Path.GetDirectoryName(assemblyPath)}{Path.DirectorySeparatorChar}{Path.GetFileNameWithoutExtension(assemblyPath)}.xml");
});
services.AddSwaggerExamplesFromAssemblyOf <Startup>();
#endregion
#region Mongo Configurations
var mongoClientSettings = MongoClientSettings.FromConnectionString(_configuration.GetConnectionString("Mongo"));
services.AddSingleton(mongoClientSettings);
services.AddSingleton <IConventionPack>(new ConventionPack
{
new EnumRepresentationConvention(BsonType.String),
new IgnoreExtraElementsConvention(true),
new IgnoreIfNullConvention(true)
});
services.AddSingleton <IMongoClient>(new MongoClient(mongoClientSettings));
services.AddScoped(typeof(IMongoBaseRepository <>), typeof(MongoBaseRepository <>));
#endregion
}
