Introduced repository without PR for mongodb.

src/Volo.Abp.MongoDB/Volo/Abp/Domain/Repositories/MongoDB/IMongoDbRepository.cs

@@ -1,17 +1,10 @@
-using System;
-using MongoDB.Driver;
+using MongoDB.Driver;
 using Volo.Abp.Domain.Entities;
 
 namespace Volo.Abp.Domain.Repositories.MongoDB
 {
-    //public interface IMongoDbRepository<TEntity> : IMongoDbRepository<TEntity, Guid>, IQueryableRepository<TEntity>
-    //    where TEntity : class, IEntity<Guid>
-    //{
-        
-    //}
-
-    public interface IMongoDbRepository<TEntity, TPrimaryKey> : IQueryableRepository<TEntity, TPrimaryKey>
-        where TEntity : class, IEntity<TPrimaryKey>
+    public interface IMongoDbRepository<TEntity> : IQueryableRepository<TEntity>
+        where TEntity : class, IEntity
     {
         IMongoDatabase Database { get; }
 
@@ -19,4 +12,10 @@ namespace Volo.Abp.Domain.Repositories.MongoDB
 
         string CollectionName { get; }
     }
+
+    public interface IMongoDbRepository<TEntity, TPrimaryKey> : IMongoDbRepository<TEntity>, IQueryableRepository<TEntity, TPrimaryKey>
+        where TEntity : class, IEntity<TPrimaryKey>
+    {
+
+    }
 }

src/Volo.Abp.MongoDB/Volo/Abp/Domain/Repositories/MongoDB/MongoDbRepository.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Threading;
@@ -10,19 +9,9 @@ using Volo.Abp.MongoDB;
 
 namespace Volo.Abp.Domain.Repositories.MongoDB
 {
-    //public class MongoDbRepository<TMongoDbContext, TEntity> : MongoDbRepository<TMongoDbContext, TEntity, Guid>, IMongoDbRepository<TEntity>
-    //    where TMongoDbContext : AbpMongoDbContext
-    //    where TEntity : class, IEntity<Guid>
-    //{
-    //    public MongoDbRepository(IMongoDatabaseProvider<TMongoDbContext> databaseProvider)
-    //        : base(databaseProvider)
-    //    {
-    //    }
-    //}
-
-    public class MongoDbRepository<TMongoDbContext, TEntity, TPrimaryKey> : QueryableRepositoryBase<TEntity, TPrimaryKey>, IMongoDbRepository<TEntity, TPrimaryKey> 
+    public class MongoDbRepository<TMongoDbContext, TEntity> : QueryableRepositoryBase<TEntity>, IMongoDbRepository<TEntity>
         where TMongoDbContext : AbpMongoDbContext
-        where TEntity : class, IEntity<TPrimaryKey>
+        where TEntity : class, IEntity
     {
         public virtual string CollectionName => DatabaseProvider.DbContext.GetCollectionName<TEntity>();
 
@@ -37,18 +26,6 @@ namespace Volo.Abp.Domain.Repositories.MongoDB
             DatabaseProvider = databaseProvider;
         }
 
-        public override async Task<TEntity> GetAsync(TPrimaryKey id, CancellationToken cancellationToken = default)
-        {
-            var entity = await FindAsync(id, cancellationToken);
-
-            if (entity == null)
-            {
-                throw new EntityNotFoundException(typeof(TEntity), id);
-            }
-
-            return entity;
-        }
-        
         public override TEntity Insert(TEntity entity, bool autoSave = false)
         {
             Collection.InsertOne(entity);
@@ -63,55 +40,109 @@ namespace Volo.Abp.Domain.Repositories.MongoDB
 
         public override TEntity Update(TEntity entity)
         {
-            var filter = Builders<TEntity>.Filter.Eq(e => e.Id, entity.Id);
-            Collection.ReplaceOne(filter, entity);
+            Collection.ReplaceOne(CreateEntityFilter(entity), entity);
             return entity;
         }
 
         public override async Task<TEntity> UpdateAsync(TEntity entity, CancellationToken cancellationToken = default)
         {
-            var filter = Builders<TEntity>.Filter.Eq(e => e.Id, entity.Id);
-            await Collection.ReplaceOneAsync(filter, entity, cancellationToken: cancellationToken);
+            await Collection.ReplaceOneAsync(CreateEntityFilter(entity), entity, cancellationToken: cancellationToken);
             return entity;
         }
 
         public override void Delete(TEntity entity)
         {
-            Delete(entity.Id);
+            Collection.DeleteOne(CreateEntityFilter(entity));
         }
 
-        public override void Delete(TPrimaryKey id)
+        public override async Task DeleteAsync(TEntity entity, CancellationToken cancellationToken = default)
         {
-            var filter = Builders<TEntity>.Filter.Eq(e => e.Id, id);
-            Collection.DeleteOne(filter);
+            await Collection.DeleteOneAsync(CreateEntityFilter(entity), cancellationToken);
         }
 
         public override void Delete(Expression<Func<TEntity, bool>> predicate)
         {
-            var filter = Builders<TEntity>.Filter.Where(predicate);
-            Collection.DeleteOne(filter);
+            Collection.DeleteMany(Builders<TEntity>.Filter.Where(predicate));
         }
 
-        public override Task DeleteAsync(TPrimaryKey id, CancellationToken cancellationToken = default)
+        public override async Task DeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
         {
-            var filter = Builders<TEntity>.Filter.Eq(e => e.Id, id);
-            return Collection.DeleteOneAsync(filter, cancellationToken: cancellationToken);
+            await Collection.DeleteManyAsync(Builders<TEntity>.Filter.Where(predicate), cancellationToken);
         }
 
-        public override Task DeleteAsync(TEntity entity, CancellationToken cancellationToken = default)
+        protected override IQueryable<TEntity> GetQueryable()
         {
-            return DeleteAsync(entity.Id, cancellationToken);
+            return Collection.AsQueryable();
         }
 
-        public override Task DeleteAsync(Expression<Func<TEntity, bool>> predicate, CancellationToken cancellationToken = default)
+        protected virtual FilterDefinition<TEntity> CreateEntityFilter(TEntity entity)
         {
-            var filter = Builders<TEntity>.Filter.Where(predicate);
-            return Collection.DeleteOneAsync(filter, cancellationToken: cancellationToken);
+            throw new NotImplementedException("CreateEntityFilter is not implemented for MongoDb by default. It should be overrided and implemented by deriving classes!");
         }
+    }
 
-        protected override IQueryable<TEntity> GetQueryable()
+    public class MongoDbRepository<TMongoDbContext, TEntity, TPrimaryKey> : MongoDbRepository<TMongoDbContext, TEntity>, IMongoDbRepository<TEntity, TPrimaryKey>
+        where TMongoDbContext : AbpMongoDbContext
+        where TEntity : class, IEntity<TPrimaryKey>
+    {
+        public MongoDbRepository(IMongoDatabaseProvider<TMongoDbContext> databaseProvider)
+            : base(databaseProvider)
         {
-            return Collection.AsQueryable();
+
+        }
+
+        public virtual TEntity Get(TPrimaryKey id)
+        {
+            var entity = Find(id);
+
+            if (entity == null)
+            {
+                throw new EntityNotFoundException(typeof(TEntity), id);
+            }
+
+            return entity;
+        }
+
+        public virtual async Task<TEntity> GetAsync(TPrimaryKey id, CancellationToken cancellationToken = default)
+        {
+            var entity = await FindAsync(id, cancellationToken);
+
+            if (entity == null)
+            {
+                throw new EntityNotFoundException(typeof(TEntity), id);
+            }
+
+            return entity;
+        }
+
+        public virtual void Delete(TPrimaryKey id)
+        {
+            Collection.DeleteOne(CreateEntityFilter(id));
+        }
+
+        public virtual Task DeleteAsync(TPrimaryKey id, CancellationToken cancellationToken = default)
+        {
+            return Collection.DeleteOneAsync(CreateEntityFilter(id), cancellationToken);
+        }
+
+        public virtual async Task<TEntity> FindAsync(TPrimaryKey id, CancellationToken cancellationToken = default)
+        {
+            return await Collection.Find(CreateEntityFilter(id)).FirstOrDefaultAsync(cancellationToken);
+        }
+
+        public virtual TEntity Find(TPrimaryKey id)
+        {
+            return Collection.Find(CreateEntityFilter(id)).FirstOrDefault();
+        }
+
+        protected override FilterDefinition<TEntity> CreateEntityFilter(TEntity entity)
+        {
+            return Builders<TEntity>.Filter.Eq(e => e.Id, entity.Id);
+        }
+
+        private static FilterDefinition<TEntity> CreateEntityFilter(TPrimaryKey id)
+        {
+            return Builders<TEntity>.Filter.Eq(e => e.Id, id);
         }
     }
 }

src/Volo.Abp.MongoDB/Volo/Abp/MongoDB/DependencyInjection/IMongoDbContextRegistrationOptionsBuilder.cs

@@ -1,4 +1,3 @@
-using Volo.Abp.Data;
 using Volo.Abp.DependencyInjection;
 
 namespace Volo.Abp.MongoDB.DependencyInjection

src/Volo.Abp.MongoDB/Volo/Abp/MongoDB/DependencyInjection/MongoDbRepositoryRegistrar.cs

@@ -21,7 +21,7 @@ namespace Volo.Abp.MongoDB.DependencyInjection
 
         protected override Type GetRepositoryType(Type dbContextType, Type entityType)
         {
-            throw new NotImplementedException();
+            return typeof(MongoDbRepository<,,>).MakeGenericType(dbContextType, entityType);
         }
 
         protected override Type GetRepositoryType(Type dbContextType, Type entityType, Type primaryKeyType)