protected virtual MongoCollection <T> GetCollection(out GenericError error)
{
string connString = GetConnection(out error);
MongoDatabase database = MongoDatabase.Create(connString);
return(database.GetCollection <T>(CollectionName));
}
private static void ConvertCollection()
{
var database = MongoDatabase.Create(url);
var fromCollectionSettings = database.CreateCollectionSettings <BsonDocument>(fromCollectionName);
fromCollectionSettings.GuidRepresentation = fromRepresentation;
var fromCollection = database.GetCollection(fromCollectionSettings);
if (!fromCollection.Exists())
{
throw new ApplicationException("From collection does not exist.");
}
var toCollectionSettings = database.CreateCollectionSettings <BsonDocument>(toCollectionName);
toCollectionSettings.GuidRepresentation = toRepresentation;
var toCollection = database.GetCollection(toCollectionSettings);
if (toCollection.Exists())
{
throw new ApplicationException("To collection already exists.");
}
foreach (var document in fromCollection.FindAll())
{
ConvertDocument(document);
toCollection.Insert(document);
}
}
public override void Initialize(string name, NameValueCollection config)
{
this.ApplicationName = config["applicationName"] ?? HostingEnvironment.ApplicationVirtualPath;
this.enablePasswordReset = Boolean.Parse(config["enablePasswordReset"] ?? "true");
this.enablePasswordRetrieval = Boolean.Parse(config["enablePasswordRetrieval"] ?? "false");
this.maxInvalidPasswordAttempts = Int32.Parse(config["maxInvalidPasswordAttempts"] ?? "5");
this.minRequiredNonAlphanumericCharacters = Int32.Parse(config["minRequiredNonAlphanumericCharacters"] ?? "1");
this.minRequiredPasswordLength = Int32.Parse(config["minRequiredPasswordLength"] ?? "7");
this.passwordAttemptWindow = Int32.Parse(config["passwordAttemptWindow"] ?? "10");
this.passwordFormat = (MembershipPasswordFormat)Enum.Parse(typeof(MembershipPasswordFormat), config["passwordFormat"] ?? "Hashed");
this.passwordStrengthRegularExpression = config["passwordStrengthRegularExpression"] ?? String.Empty;
this.requiresQuestionAndAnswer = Boolean.Parse(config["requiresQuestionAndAnswer"] ?? "false");
this.requiresUniqueEmail = Boolean.Parse(config["requiresUniqueEmail"] ?? "true");
if (this.PasswordFormat == MembershipPasswordFormat.Hashed && this.EnablePasswordRetrieval)
{
throw new ProviderException("Configured settings are invalid: Hashed passwords cannot be retrieved. Either set the password format to different type, or set enablePasswordRetrieval to false.");
}
this.mongoCollection = MongoDatabase.Create(
ConfigurationManager.ConnectionStrings[config["connectionStringName"] ?? "MongoConnection"].ConnectionString ?? "mongodb://localhost")
.GetCollection(config["collection"] ?? "Users");
this.mongoCollection.EnsureIndex("ApplicationName");
this.mongoCollection.EnsureIndex("ApplicationName", "Email");
this.mongoCollection.EnsureIndex("ApplicationName", "Username");
base.Initialize(name, config);
}
public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
{
MembershipUser retval = null;
ObjectId id = default(ObjectId);
string key = providerUserKey.ToString();
if (!string.IsNullOrWhiteSpace(key) && !ObjectId.TryParse(key, out id))
{
throw new Exception("The providerUserKey parameter cannot be converted to a valid ObjectID.");
}
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
var users = db.GetCollection <MongoUser>(typeof(MongoUser).Name);
var user = users.AsQueryable().SingleOrDefault(u => u._id == id);
if (user != null)
{
retval = user.ToMembershipUser();
if (userIsOnline)
{
user.LastActivityDate = DateTime.Now;
users.Save(user);
}
}
}
return(retval);
}
public void Polymorphic_objects_should_deserialize()
{
var database = MongoDatabase.Create("connection_string");
var collection = database.GetCollection("vehicles");
var car = new Car
{
wheels = new List <Wheel>
{
new WheelA {
propA = 123
},
new WheelB {
propB = 456
}
}
};
collection.Insert(car);
var fetched = collection.AsQueryable <Car>()
.SingleOrDefault(x => x.Id == car.Id);
Assert.IsNotNull(fetched.wheels);
Assert.AreEqual(2, fetched.wheels.Count);
Assert.IsInstanceOfType(fetched.wheels[0], typeof(WheelA));
Assert.IsInstanceOfType(fetched.wheels[1], typeof(WheelB));
Assert.AreEqual(123, (fetched.wheels[0] as WheelA).propA);
Assert.AreEqual(456, (fetched.wheels[1] as WheelB).propB);
}
static void ConfigureDefaultMongoDbIfNecessary(MessageBusConfigurator cfg)
{
string connstr, collection;
if (!Util.ParseMongoEndpoint(cfg.Endpoint, out connstr, out collection))
{
throw new Exception("Invalid mongo connection string: " + cfg.Endpoint);
}
var dic = new Dictionary <string, string>();
foreach (var cs in cfg.GetConnectionStrings())
{
if (cs.Name == null || dic.ContainsKey(cs.Name))
{
continue;
}
dic[cs.Name] = cs.ConnectionString;
}
var cstr = Util.GetMongoConnectionStringForEndpoint(cfg.Endpoint, dic);
cfg.CustomizeContainer(wc =>
{
if (!MessageBusConfigurator.IsServiceRegistered(wc, typeof(MongoDatabase)))
{
wc.Register(Component.For <MongoDatabase>()
.Instance(MongoDatabase.Create(cstr)));
}
});
}
public override string GetPassword(string username, string answer)
{
if (!EnablePasswordRetrieval)
{
throw new ProviderException("Password Retrieval Not Enabled.");
}
else if (PasswordFormat == MembershipPasswordFormat.Hashed)
{
throw new ProviderException("Cannot retrieve Hashed passwords.");
}
MongoUser user = null;
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
user = db.GetCollection <MongoUser>(typeof(MongoUser).Name).AsQueryable().SingleOrDefault(u => u.UserName == username);
}
if (user == null)
{
throw new MembershipPasswordException("The supplied user name is not found.");
}
else if (user.IsLockedOut)
{
throw new MembershipPasswordException("The supplied user is locked out.");
}
else if (RequiresQuestionAndAnswer && !CheckPassword(answer, user.PasswordAnswer))
{
UpdateFailureCount(username, "passwordAnswer");
throw new MembershipPasswordException("Incorrect password answer.");
}
return(UnEncodePassword(user.Password));
}
protected void Button2_Click(object sender, EventArgs e)
{
string connString = WebConfigurationManager.AppSettings["mongoConnectionString"];
var db = MongoDatabase.Create(connString);
MongoCollection collection = db.GetCollection("guids");
collection.RemoveAll();
MongoCursor <BsonDocument> cursor = collection.FindAllAs <BsonDocument>();
DataTable dt = new DataTable();
dt.Columns.Add("Date", typeof(DateTime));
dt.Columns.Add("Value", typeof(String));
foreach (var item in cursor)
{
dt.Rows.Add(item["Date"], item["Value"]);
}
GridView1.DataSource = dt;
GridView1.DataBind();
}
public static IContainer Initialize()
{
var pluralizer = PluralizationService.CreateService(CultureInfo.CurrentCulture);
ObjectFactory.Initialize(x =>
{
x.Scan(scan =>
{
scan.TheCallingAssembly();
scan.WithDefaultConventions();
});
x.For <MongoDatabase>().Use(() => MongoDatabase.Create(Config.MongoUrl));
x.For(typeof(MongoCollection <>)).Use(context =>
{
var db = context.GetInstance <MongoDatabase>();
var type = context.BuildStack.Current.RequestedType;
var modelType = type.GetGenericArguments()[0];
var collectionName = pluralizer.Pluralize(modelType.Name);
return(db.GetCollection(modelType, collectionName));
});
x.For <IMailSender>().Use <SendGridMailSender>();
x.For <NetworkCredential>().Use(new NetworkCredential(Config.SendGrid.User,
Config.SendGrid.Password));
});
return(ObjectFactory.Container);
}
public override bool ValidateUser(string username, string password)
{
bool isValid = false;
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
var users = db.GetCollection <MongoUser>(typeof(MongoUser).Name);
var user = users.AsQueryable().SingleOrDefault(u => u.UserName == username);
if (user != null && !string.IsNullOrWhiteSpace(user.UserName) && user.IsApproved && !user.IsLockedOut)
{
if (CheckPassword(password, user.Password))
{
user.LastLoginDate = DateTime.Now;
users.Save(user);
isValid = true;
}
else
{
UpdateFailureCount(username, "password");
}
}
}
return(isValid);
}
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
{
CheckRolesExist(roleNames);
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
foreach (string username in usernames)
{
var permissions = db.GetCollection <MongoPermission>(typeof(MongoPermission).Name);
var permission = permissions.AsQueryable().SingleOrDefault(p => p.Username == username);
if (permission != null)
{
permission.Roles.RemoveAll(r => roleNames.Contains(r));
if (permission.Roles.Count == 0)
{
permissions.Remove(Query.EQ("_id", permission._id));
}
else
{
permissions.Save(permission);
}
}
}
}
}
private void InitializeConnection(string connectionString)
{
var database = MongoDatabase.Create(connectionString);
_collection = database.GetCollection <User>("users");
_collection.CreateIndex(IndexKeys <User> .Hashed(index => index.Id));
}
public MongoQueue(MongoQueConfig config)
{
// our queue name will be the same as the message class
_database = MongoDatabase.Create(config.ConnectionString);
if (!_database.CollectionExists(_queueName))
{
try
{
Log.InfoFormat("Creating queue '{0}' size {1}", _queueName, config.QueueSize);
var options = CollectionOptions
.SetCapped(true) // use a capped collection so space is pre-allocated and re-used
.SetAutoIndexId(true)
.SetMaxSize(config.QueueSize); // limit the size of the collection and pre-allocated the space to this number of bytes
_database.CreateCollection(_queueName, options);
var col = _database.GetCollection(_queueName);
col.EnsureIndex(new[] { "Dequeued" });
col.EnsureIndex(new[] { "Equeued" });
}
catch
{
// assume that any exceptions are because the collection already exists ...
}
}
// get the queue collection for our messages
_queue = _database.GetCollection <MongoMessage <T> >(_queueName);
}
public virtual IPersistStreams Build()
{
var connectionString = this.TransformConnectionString(this.GetConnectionString());
var database = MongoDatabase.Create(connectionString);
return(new MongoPersistenceEngine(database, this.serializer));
}
protected Catalog()
{
var dbUrl = ConfigurationManager.AppSettings["MONGOLAB_URI"] ?? "mongodb://localhost/BandAppDb";
var connectionString = string.Format(CultureInfo.InvariantCulture, "{0}?safe=true", dbUrl);
_database = MongoDatabase.Create(connectionString); // TODO: remove usage of obsolete method
}
public override MembershipUserCollection FindUsersByEmail(string emailToMatch, int pageIndex, int pageSize, out int totalRecords)
{
MembershipUserCollection users = new MembershipUserCollection();
List <MongoUser> results = null;
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
results = db.GetCollection <MongoUser>(typeof(MongoUser).Name).AsQueryable().Where(u => u.Email == emailToMatch).ToList();
}
int counter = 0;
int startIndex = pageSize * pageIndex;
int endIndex = startIndex + pageSize - 1;
results.ForEach(u =>
{
if (counter >= startIndex && counter <= endIndex)
{
users.Add(u.ToMembershipUser());
counter++;
}
});
totalRecords = counter - startIndex;
return(users);
}
public TimesheetsController()
{
var connectionString = ConfigurationManager.AppSettings["MONGOHQ_URL"];
_mongoDb = MongoDatabase.Create(connectionString);
_repository = _mongoDb.GetCollection <Timesheet>(typeof(Timesheet).Name);
}
public MongoRepositoryService(bool safe = false)
{
db = MongoDatabase.Create(WebConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString);
if (safe)
{
safeMode = SafeMode.True;
}
}
public IStoreSagaData CreatePersister()
{
db = MongoDatabase.Create(ConnectionStrings.MongoDb);
db.Drop();
return(new MongoDbSagaPersister(ConnectionStrings.MongoDb)
.AllowAutomaticSagaCollectionNames());
}
public void SetUp()
{
TimeMachine.Reset();
db = MongoDatabase.Create(ConnectionStrings.MongoDb);
db.Drop();
DoSetUp();
}
public override string ResetPassword(string username, string answer)
{
if (!EnablePasswordReset)
{
throw new ProviderException("Password Reset Not Enabled.");
}
else if (answer == null && RequiresQuestionAndAnswer)
{
UpdateFailureCount(username, "passwordAnswer");
throw new ProviderException("Password answer required for password reset.");
}
string newPassword = Membership.GeneratePassword(NewPasswordLength, MinRequiredNonAlphanumericCharacters);
ValidatePasswordEventArgs args = new ValidatePasswordEventArgs(username, newPassword, true);
OnValidatingPassword(args);
if (args.Cancel)
{
if (args.FailureInformation != null)
{
throw args.FailureInformation;
}
else
{
throw new MembershipPasswordException("Reset password canceled due to password validation failure.");
}
}
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
var users = db.GetCollection <MongoUser>(typeof(MongoUser).Name);
var user = users.AsQueryable().SingleOrDefault(u => u.UserName == username);
if (string.IsNullOrWhiteSpace(user.UserName))
{
throw new MembershipPasswordException("The supplied user name is not found.");
}
else if (user.IsLockedOut)
{
throw new MembershipPasswordException("The supplied user is locked out.");
}
else if (RequiresQuestionAndAnswer && !CheckPassword(answer, user.PasswordAnswer))
{
UpdateFailureCount(username, "passwordAnswer");
throw new MembershipPasswordException("Incorrect password answer.");
}
user.Password = EncodePassword(newPassword);
user.LastPasswordChangedDate = DateTime.Now;
users.Save(user);
}
return(newPassword);
}
private void DropCollection(string name)
{
var connectionString = ConfigurationManager.ConnectionStrings["mongo-queue"].ConnectionString;
var db = MongoDatabase.Create(connectionString);
if (db.CollectionExists(name))
{
db.DropCollection(name);
}
}
public MongoDBStorage()
{
string connectionString = ConfigurationManager.ConnectionStrings["MongoDBStorage"].ConnectionString;
var database = MongoDatabase.Create(connectionString);
Revisions = database.GetCollection <RevisionModel>("revisions");
Users = database.GetCollection <UserModel>("users");
CreateAdmin();
}
public override void Initialize(string name, NameValueCollection config)
{
this.mongoCollection = MongoDatabase.Create(ConnectionHelper.GetDatabaseConnectionString(config)).GetCollection(config["collection"] ?? "WebEvents");
config.Remove("collection");
config.Remove("connectionString");
config.Remove("database");
base.Initialize(name, config);
}
public override string[] GetAllRoles()
{
string[] retval = new string[0];
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
retval = db.GetCollection <MongoRole>(typeof(MongoRole).Name).AsQueryable().Select(r => r.Name).ToArray();
}
return(retval);
}
public override bool RoleExists(string roleName)
{
bool retval = false;
var db = MongoDatabase.Create(ConnectionString);
using (db.RequestStart())
{
retval = db.GetCollection <MongoRole>(typeof(MongoRole).Name).AsQueryable().Count(r => r.Name == roleName) > 0;
}
return(retval);
}
public override string GetUserNameByEmail(string email)
{
string retval = null;
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
var user = db.GetCollection <MongoUser>(typeof(MongoUser).Name).AsQueryable().SingleOrDefault(u => u.Email == email);
retval = user != null ? user.UserName : null;
}
return(retval);
}
public override void Initialize(string name, NameValueCollection config)
{
this.mongoCollection = MongoDatabase.Create(
ConfigurationManager.ConnectionStrings[config["connectionStringName"] ?? "MongoConnection"].ConnectionString ?? "mongodb://localhost")
.GetCollection(config["collection"] ?? "WebEvents");
config.Remove("collection");
config.Remove("connectionStringName");
base.Initialize(name, config);
}
public override bool UnlockUser(string username)
{
var db = MongoDatabase.Create(ConnectionString); using (db.RequestStart())
{
var users = db.GetCollection <MongoUser>(typeof(MongoUser).Name);
var user = users.AsQueryable().SingleOrDefault(u => u.UserName == username);
user.IsLockedOut = false;
users.Save(user);
}
return(true);
}
public MongoDBEventStore(string connectionString = DEFAULT_DATABASE_URI, IEventTypeResolver typeResolver = null, IEventConverter converter = null)
{
_database = MongoDatabase.Create(connectionString);
_commits = _database.GetCollection <MongoCommit>("Commits");
_events = _database.GetCollection <BsonDocument>("SourcedEvents");
_converter = converter ?? new NullEventConverter();
_formatter = new JsonEventFormatter(typeResolver ?? new SimpleEventTypeResolver());
_translator = new StringEventTranslator();
EnsureIndexes();
}
