public CollectionExpression(Alias alias, IMongoDatabase database, string collectionName, Type documentType)
     : base(MongoExpressionType.Collection, typeof(void), alias)
 {
     CollectionName = collectionName;
     Database = database;
     DocumentType = documentType;
 }

        public ICollection<Product> GetAllProducts(IMongoDatabase database, string collectionName)
        {
            var collection = database.GetCollection<Product>(collectionName);
            var rest = collection.Find(_ => true).ToListAsync().Result;

            return rest;
        }

		private async void firstTimeInstallDataBase (IMongoDatabase database, string rootPath){
			try {
				if (!CollectionExistsAsync (database, "actors").Result) {
					await database.CreateCollectionAsync ("actors");

					var actors = new ActorRepository();
					foreach (Actor actor in actors.Retrieve(rootPath))
					{
						var collectionActors = database.GetCollection<Actor>("actors");
						await collectionActors.InsertOneAsync(actor);
					}
				}

				if (!CollectionExistsAsync (database, "movies").Result) {
					await database.CreateCollectionAsync ("movies");

					var movies = new MovieRepository();
					foreach (Movie movie in movies.Retrieve(rootPath))
					{
						var collectionActors = database.GetCollection<Movie>("movies");
						await collectionActors.InsertOneAsync(movie);
					}
				}
			}
			catch {
				throw;
			}
		}

		public MongoDBStorage(IMongoDatabase database)
		{
			Revisions = database.GetCollection<RevisionModel>("revisions");
			Users = database.GetCollection<UserModel>("users");

			Task.Run(() => SetUp()).Wait();
		}

        public IMongoCollection<BsonDocument> GetCollection(IMongoDatabase mongoDatabase, bool? cappedCollection,
            string collectionName, long? cappedCollectionSize, long? maxNumberOfDocuments)
        {
            IMongoCollection<BsonDocument> retVal = null;

            if (cappedCollection == null || !cappedCollection.Value)
            {
                retVal = mongoDatabase.GetCollection<BsonDocument>(collectionName ?? CollectionDefaulName);
                return retVal;
            }
            
            if (!IsCollectionExistsAsync(mongoDatabase, collectionName).Result)
            {
                CreateCollectionAsync(mongoDatabase, collectionName, cappedCollectionSize, maxNumberOfDocuments).Wait();
                retVal = mongoDatabase.GetCollection<BsonDocument>(collectionName ?? CollectionDefaulName);
                return retVal;
            }

            if (IsCappedCollection(collectionName, mongoDatabase).Result)
            {
                retVal = mongoDatabase.GetCollection<BsonDocument>(collectionName ?? CollectionDefaulName);
                return retVal;
            }


            if (ConvertCollectionToCapped(collectionName, mongoDatabase, cappedCollectionSize, maxNumberOfDocuments).Result)
            {
                retVal = mongoDatabase.GetCollection<BsonDocument>(collectionName ?? CollectionDefaulName);
            }
            
            return retVal;
        }

 public TokenHandleStore(IMongoDatabase db, 
     StoreSettings settings, 
     IClientStore clientStore) 
     : base(db, settings.TokenHandleCollection)
 {
     _serializer = new TokenSerializer(clientStore);
 }

 public AdminService(IMongoClient client, IMongoDatabase db, StoreSettings settings)
 {
     _client = client;
     _db = db;
     _settings = settings;
     _clientSerializer = new ClientSerializer();
 }

        public ICollection<Trader> GetAllTraders(IMongoDatabase database)
        {
            var collection = database.GetCollection<Trader>(TradersCollectionName);
            var rest = collection.Find(t => true).ToListAsync().Result;

            return rest;
        }

        public MongoConfigurationRepository(string connection, string databaseName)
        {
            var mongoClient = new MongoClient(MongoClientSettings.FromUrl(new MongoUrl(connection ?? Connection)));
            database = mongoClient.GetDatabase(databaseName ?? DatabaseName);

            InitCollection();
        }

 public void Init()
 {
     Client = new MongoClient(ConnString);
     DataBase = Client.GetDatabase("mongoLog");
     Users = DataBase.GetCollection<User>("Users");
     Datas = DataBase.GetCollection<Data>("Datas");
 }

        static MProjects()
        {
            var connectionString = Settings.Default.MongoConnectionString;
            var mongoClient = new MongoClient(connectionString);

            Database = mongoClient.GetDatabase(Settings.Default.MongoDBName);
        }

        public Querying()
        {
            client = new MongoClient(); ;
            database = client.GetDatabase("test");

            collection = database.GetCollection<Student>("Users");
        }

 public Logger(string logger)
 {
     var client = new MongoClient(Properties.Settings.Default.Mongo_log);
     _db = client.GetDatabase("patientcarelog");
     _logCollection = _db.GetCollection<BsonDocument>("Logs");
     _logger = logger;
 }

 /// <summary>
 /// Details controller constructor
 /// </summary>
 public DetailController()
 {
     var client = new MongoClient(ConfigurationManager.ConnectionStrings["Mongo_patientcare"].ConnectionString);
     _log = new Logger("WebAPI:DetailController");
     _db = client.GetDatabase("patientcaredb");
     _details = _db.GetCollection<BsonDocument>("Detail");
 }

 private void InitiateDatabase()
 {
     var connectionString = ConfigurationManager.ConnectionStrings["Mongo.ConnectionString"].ConnectionString;
     var mongoUrlBuilder = new MongoUrlBuilder(connectionString);
     mongoClient = new MongoClient(mongoUrlBuilder.ToMongoUrl());
     Database = mongoClient.GetDatabase(mongoUrlBuilder.DatabaseName);
 }

 /// <summary />
 public PatientRepository()
 {
     var client = new MongoClient(ConfigurationManager.ConnectionStrings["Mongo_patientcare_datamock"].ConnectionString);
     _log = new Logger("WebAPI : PatientRepository");
     _db = client.GetDatabase("patientcare_datamock");
     _patients = _db.GetCollection<BsonDocument>("Patients");
 }

 public TodoItemRepository(string mongoConnection, string databaseName)
 {
     collectionName = "todoitems";
     var client = new MongoClient(mongoConnection);
     this.database = client.GetDatabase(databaseName);
     this.collection = database.GetCollection<TodoItem>(collectionName);
 }

 public MongoDbBase(string connectionString, string database)
 {
     this.connectionString = connectionString;
     this.database = database;
     Client = new MongoClient(connectionString);
     Database = Client.GetDatabase(database);
 }

 public void Initialize()
 {
     var connect = "mongodb://localhost";
     _client = new MongoClient(connect);
     _db = _client.GetDatabase("local");
     _collection = _db.GetCollection<Person>("Person");
 }

        public ClothesDbContext(string connectionString)
        {
            var mongoClient = new MongoClient(connectionString);
            _mongoDatabase = mongoClient.GetDatabase("ClothesWashing");

            RegisterClassMaps();
        }