public static async Task ApplyIndexingAsync <TEntity>(IMongoDbConnection connection, CancellationToken cancellationToken = default) where TEntity : class
{
if (HasAppliedIndexes.TryGetValue(typeof(TEntity), out var hasApplied) && hasApplied)
{
return;
}
var indexModel = IndexModelBuilder <TEntity> .BuildModel().ToArray();
if (indexModel.Length > 0)
{
var definition = EntityMapping.GetOrCreateDefinition(typeof(TEntity));
using (var diagnostics = DiagnosticRunner.Start(connection, indexModel))
{
try
{
var collection = connection.GetDatabase().GetCollection <TEntity>(definition.CollectionName);
await collection.Indexes.CreateManyAsync(indexModel, cancellationToken).ConfigureAwait(false);
HasAppliedIndexes.TryAdd(typeof(TEntity), true);
}
catch (Exception exception)
{
diagnostics.Error(exception);
throw;
}
}
}
}
public void MutateEntity(TEntity entity, MutatorType mutationType, IMongoDbConnection connection)
{
var definition = EntityMapping.GetOrCreateDefinition(typeof(TEntity));
var mutatePropertiesMap = definition.GetAllProperties().Select(p => new
{
Property = p,
MutateAttribute = p.PropertyInfo.GetCustomAttribute <MutatePropertyAttribute>(true)
}).Where(p => p.MutateAttribute != null).ToArray();
foreach (var propertyMap in mutatePropertiesMap)
{
if (mutationType == MutatorType.Insert)
{
propertyMap.MutateAttribute.OnInsert(entity, propertyMap.Property);
}
if (mutationType == MutatorType.Update)
{
propertyMap.MutateAttribute.OnUpdate(entity, propertyMap.Property);
}
if (mutationType == MutatorType.Select)
{
propertyMap.MutateAttribute.OnSelect(entity, propertyMap.Property);
}
}
}
public void ProcessEntity(TEntity entity, IMongoDbConnection connection)
{
foreach (var processor in this)
{
processor.ProcessEntity(entity, connection);
}
}
public void MutateEntity(TEntity entity, MutatorType mutationType, IMongoDbConnection connection)
{
var relationships = EntityMapping.GetOrCreateDefinition(typeof(TEntity)).Relationships;
foreach (var relationship in relationships)
{
if (mutationType == MutatorType.Select && !relationship.IsCollection)
{
var initialiseSingleEntityMethod = GetType().GetMethod(nameof(InitialiseSingleEntityRelationship), BindingFlags.NonPublic | BindingFlags.Static).MakeGenericMethod(relationship.EntityType);
initialiseSingleEntityMethod.Invoke(entity, new object[] { entity, relationship, connection });
}
else if (mutationType == MutatorType.Create && relationship.IsCollection)
{
var navigationCollectionType = typeof(EntityNavigationCollection <>).MakeGenericType(relationship.EntityType);
var navigationCollection = Activator.CreateInstance(navigationCollectionType, relationship.IdProperty) as IEntityNavigationCollectionBase;
navigationCollection.SetConnection(connection);
relationship.NavigationProperty.SetValue(entity, navigationCollection);
}
else if (mutationType == MutatorType.Select && relationship.IsCollection)
{
if (relationship.NavigationProperty.GetValue(entity) is IEntityNavigationCollectionBase navigationCollection)
{
navigationCollection.SetConnection(connection);
}
}
}
}
public MongoDbDatabase(
[NotNull] DatabaseDependencies databaseDependencies,
[NotNull] IMongoDbConnection mongoDbConnection)
: base(Check.NotNull(databaseDependencies, nameof(databaseDependencies)))
{
_mongoDbConnection = Check.NotNull(mongoDbConnection, nameof(mongoDbConnection));
}
public DemoService(IMongoDbConnection connection)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_demo = database.GetCollection <Demo>(MongoCollection.DemoCollection);
}
public CustomerRepo(IMongoDbConnection mongoDbConnection)
: base(mongoDbConnection)
{
this.service = new CustomerService(mongoDbConnection);
this.converter = new CustomerConverter();
}
/// <inheritdoc />
public MongoDbQueryContextFactory(
[NotNull] QueryContextDependencies queryContextDependencies,
[NotNull] IMongoDbConnection mongoDbConnection)
: base(Check.NotNull(queryContextDependencies, nameof(queryContextDependencies)))
{
_mongoDbConnection = Check.NotNull(mongoDbConnection, nameof(mongoDbConnection));
}
protected BaseMongoService(IMongoDbConnection mongoDbConnection)
{
this.dbName = mongoDbConnection.DatabaseName;
this.connectionString = mongoDbConnection.ConnectionString;
this.GetCollection();
}
public UserRoleServices(ILogger <UserLoginServices> logger, IMongoDbConnection connection)
{
_logger = logger;
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_userRole = database.GetCollection <UserRole>(Common.MongoCollection.UserRoles);
}
public GreenServices(ILogger <GreenServices> logger, IMongoDbConnection connection)
{
_logger = logger;
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_green = database.GetCollection <Green>(Common.MongoCollection.Green);
}
public GCCMotoService(IMongoDbConnection connection, ILogger <GCCMotoService> logger)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_collection = database.GetCollection <GCCMotoInsuranceModel>(MongoCollection.GCCMotoInsurance);
_logger = logger;
}
public ProductServices(ILogger <ProductServices> logger, IMongoDbConnection connection)
{
_logger = logger;
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_product = database.GetCollection <Product>(Common.MongoCollection.Product);
}
public GCCProductService(IMongoDbConnection connection, ILogger <GCCProductService> logger)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_collection = database.GetCollection <GCCPersonalProduct>(MongoCollection.GCCProduct);
_logger = logger;
}
public DataMCProcessingServices(ILogger <DataMCProcessingServices> logger, IMongoDbConnection connection)
{
_logger = logger;
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_dataMCProcessing = database.GetCollection <DataMCProcessing>(Common.MongoCollection.DataMCProcessing);
}
public FileUploadServices(ILogger <FileUploadServices> logger, IMongoDbConnection connection)
{
_logger = logger;
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_fileUpload = database.GetCollection <FileUpload>(Common.MongoCollection.FileUpload);
}
public CustomerServices(IMongoDbConnection connection, ILogger <CustomerServices> logger)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_customer = database.GetCollection <Customer>(MongoCollection.CustomerCollection);
_logger = logger;
}
public DocumentCategoryServices(ILogger <DocumentCategoryServices> logger, IMongoDbConnection connection)
{
_logger = logger;
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_loaiHS = database.GetCollection <DocumentCategory>(Common.MongoCollection.LoaiHoSo);
}
public RoleServices(IMongoDbConnection connection, ILogger <RoleServices> logger)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_role = database.GetCollection <Roles>(MongoCollection.RolesCollection);
_logger = logger;
}
public MobileVersionServices(ILogger <MobileVersionServices> logger, IMongoDbConnection connection)
{
_logger = logger;
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_mobileVersion = database.GetCollection <MobileVersion>(Common.MongoCollection.MobileVersion);
}
public MongoUnitOfWork(IMongoDbConnection connection)
{
MongoUrl url = new MongoUrl(connection.GetConnectionString());
MongoClient client = new MongoClient(url);
_database = client.GetDatabase(url.DatabaseName);
}
public ConfigServices(IMongoDbConnection connection, ILogger <NotificationServices> logger)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_collection = database.GetCollection <ConfigModel>(MongoCollection.Config);
_logger = logger;
}
public GCCMotoProgramService(IMongoDbConnection connection, ILogger <GCCMotoProgramService> logger)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_collection = database.GetCollection <GCCMotoProgramModel>(MongoCollection.GCCMotoProgram);
_motoCollection = database.GetCollection <GCCKindMotoModel>(MongoCollection.GCCKindMoto);
_logger = logger;
}
public void ProcessEntity(TEntity entity, IMongoDbConnection connection)
{
var entry = EntityCollection.GetEntry(entity);
if (entry == null || entry.State != EntityEntryState.Deleted)
{
EntityCollection.Update(entity, EntityEntryState.NoChanges);
}
}
//private readonly IDataProtectionProvider _dataProtectionProvider;
public UserServices(IMongoDbConnection connection, ILogger <UserServices> logger)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_user = database.GetCollection <User>(MongoCollection.UsersCollection);
_logger = logger;
// _dataProtectionProvider = dataProtectionProvider;
}
/// <summary>
/// Initializes a new instance of hte <see cref="MongoDbDatabase"/> class.
/// </summary>
/// <param name="databaseDependencies">Parameter object containing dependencies for this service.</param>
/// <param name="mongoDbConnection">A <see cref="IMongoDbConnection"/> used to communicate with the MongoDB instance.</param>
/// <param name="mongoDbWriteModelFactorySelector">The <see cref="IMongoDbWriteModelFactorySelector"/> to use to create
/// <see cref="IMongoDbWriteModelFactory{TEntity}"/> instances.</param>
public MongoDbDatabase(
[NotNull] DatabaseDependencies databaseDependencies,
[NotNull] IMongoDbConnection mongoDbConnection,
[NotNull] IMongoDbWriteModelFactorySelector mongoDbWriteModelFactorySelector)
: base(Check.NotNull(databaseDependencies, nameof(databaseDependencies)))
{
_mongoDbConnection = Check.NotNull(mongoDbConnection, nameof(mongoDbConnection));
_mongoDbWriteModelFactorySelector = Check.NotNull(mongoDbWriteModelFactorySelector, nameof(mongoDbWriteModelFactorySelector));
}
public void ProcessEntity(TEntity entity, IMongoDbConnection connection)
{
var entry = Context.ChangeTracker.GetEntry(entity);
if (entry == null || entry.State == EntityEntryState.NoChanges)
{
Context.ChangeTracker.SetEntityState <TEntity>(entity, EntityEntryState.NoChanges);
}
}
public AuthRefreshServices(IMongoDbConnection connection, IConfiguration config, ILogger <AuthRefreshServices> logger)
{
var client = new MongoClient(connection.ConnectionString);
var database = client.GetDatabase(connection.DataBase);
_authRefresh = database.GetCollection <AuthRefresh>(MongoCollection.AuthRefresh);
//_dataProtectionProvider = dataProtectionProvider;
_config = config;
_logger = logger;
}
public MongoDbQueryContext([NotNull] Func <IQueryBuffer> queryBufferFactory,
[NotNull] LazyRef <IStateManager> stateManager,
[NotNull] IConcurrencyDetector concurrencyDetector,
[NotNull] IMongoDbConnection connection)
: base(queryBufferFactory, stateManager, concurrencyDetector)
{
Check.NotNull(connection, nameof(connection));
_connection = connection;
}
public IEnumerable <BsonDocument> ExecuteFind([NotNull] IMongoDbConnection connection)
{
Check.NotNull(connection, nameof(connection));
connection.OpenDatabase();
var result = connection.ExecuteQuery(_collectionName, _projectionString);
return(result);
}
protected MongoDbWatcher(string name, MongoDbWatcherConfiguration configuration)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentException("Watcher name can not be empty.");
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration),
"MongoDB Watcher configuration has not been provided.");
}
Name = name;
_configuration = configuration;
_connection = configuration.ConnectionProvider(configuration.ConnectionString);
}
