public static void SetStatus(BsonDocument service, bool restart)
{
try
{
var server = MongoServer.Create(ConfigurationManager.ConnectionStrings["mongodb"].ConnectionString);
server.Connect();
var database = server.GetDatabase("config");
var collection = database.GetCollection("services");
var filter = new QueryDocument { { "_id", service["_id"].AsObjectId } };
var update = new UpdateDocument();
foreach (var key in service)
update[key.Name] = key.Value;
update["restart"] = restart;
collection.Update(filter, update);
server.Disconnect();
}
catch (Exception err)
{
Console.WriteLine("** error updating restart status: " + err.Message);
}
}
public static UpdateDocument ToUpdateDocument(this TextContent content)
{
UpdateDocument doc = new UpdateDocument();
foreach (var item in content)
{
doc[item.Key] = BsonHelper.Create(item.Value);
}
return doc;
}
public static UpdateDocument ToUpdateDocument(this TextContent textContent)
{
textContent = textContent.ConvertToUTCTime();
UpdateDocument doc = new UpdateDocument();
foreach (var item in textContent)
{
doc[item.Key] = BsonHelper.Create(item.Value);
doc[GetCaseInsensitiveFieldName(item.Key)] = BsonHelper.Create(ToCaseInsensitiveValue(item.Value));
}
return doc;
}
private void MarkExisting(BsonDocument document)
{
BsonValue id = document.GetValue(Field.RESOURCEID);
IMongoQuery query = Query.And(Query.EQ(Field.RESOURCEID, id), Query.EQ(Field.STATE, Value.CURRENT));
IMongoUpdate update = new UpdateDocument("$set",
new BsonDocument
{
{ Field.TRANSACTION, transid },
}
);
collection.Update(query, update, UpdateFlags.Multi);
}
public void MarkExisting(IEnumerable<BsonDocument> documents)
{
IEnumerable<BsonValue> keys = KeysOf(documents);
IMongoUpdate update = new UpdateDocument("$set",
new BsonDocument
{
{ Field.TRANSACTION, this.transid },
}
);
IMongoQuery query = Query.And(Query.EQ(Field.STATE, Value.CURRENT), Query.In(Field.RESOURCEID, keys));
collection.Update(query, update, UpdateFlags.Multi);
}
public string Edit(int dvid, int ssid, BsonDocument data)
{
if (!DataDV.GetDV().CheckConnected())
{
return Errors.e7006;
}
var query1 = Query.EQ("dvid", dvid);
var query2 = Query.EQ("ssid", ssid);
var query = Query.And(query1, query2);
UpdateDocument update = new UpdateDocument("$set", data);
sss.Update(query, update, UpdateFlags.Upsert);
return string.Empty;
}
public int Update(MongoCollection<BsonDocument> collection, IDictionary<string, object> data, SimpleExpression criteria)
{
var condition = _expressionFormatter.Format(criteria);
MongoIdKeys.ReplaceId(data);
var update = new UpdateDocument("$set", data.ToBsonDocument());
var result = collection.Update(condition, update, UpdateFlags.Multi);
if (result != null)
return (int)result.DocumentsAffected;
return int.MaxValue;
}
public void Update(Currency currency)
{
var collection = GetCollection();
var query = new QueryDocument {
{ "Name", currency.Name }
};
var update = new UpdateDocument {
{ "$set", new BsonDocument {
{ "updated_at", currency.updated_at },
{"Curs", currency.Curs}
}
}
};
collection.Update(query, update);
}
public int Update(MongoCollection<BsonDocument> collection, IDictionary<string, object> data, SimpleExpression criteria)
{
var condition = _expressionFormatter.Format(criteria);
if (data.ContainsKey("Id"))
{
data["_id"] = data["Id"];
data.Remove("Id");
}
var update = new UpdateDocument("$set", data.ToBsonDocument());
var result = collection.Update(condition, update, UpdateFlags.Multi);
if (result != null)
return (int)result.DocumentsAffected;
return int.MaxValue;
}
private void MarkExisting(BsonDocument document)
{
BsonValue id = document.GetValue(Field.Key);
IMongoQuery query = Query.And(Query.EQ(Field.Key, id), Query.EQ(Field.Status, Value.Current));
IMongoUpdate update = new UpdateDocument("$set",
new BsonDocument
{
{ Field.Transaction, transid },
}
);
collection.Update(query, update, UpdateFlags.Multi);
}
public void MarkExisting(IEnumerable<BsonDocument> documents)
{
IEnumerable<BsonValue> keys = KeysOf(documents);
IMongoUpdate update = new UpdateDocument("$set",
new BsonDocument
{
{ Field.Transaction, this.transid },
}
);
IMongoQuery query = Query.And(Query.EQ(Field.Status, Value.Current), Query.In(Field.Key, keys));
collection.Update(query, update, UpdateFlags.Multi);
}
public void PutNextVersion(UpdateDocument updateDoc, object entity)
{
var version = this.Accessor.GetValue(entity);
object nextVersion;
var type = this.Descriptor.Property.PropertyType;
if (type == typeof(int))
{
nextVersion = (int)version + 1;
}
else if (type == typeof(long))
{
nextVersion = Int64Version.GetCurrent();
}
else if (type == typeof(DateTime))
{
nextVersion = DateTimeVersion.GetCurrent();
}
else
{
throw new NotSupportedException(String.Format("Don't support type {0} as version.", type));
}
((IPropertyUpdateOperator)this).PutConstantUpdate(updateDoc, nextVersion);
}
public void RemoveTransaction(string transid)
{
IMongoQuery query = Query.EQ(Field.TRANSACTION, transid);
IMongoUpdate update = new UpdateDocument("$set",
new BsonDocument
{
{ Field.TRANSACTION, 0 }
}
);
collection.Update(query, update, UpdateFlags.Multi);
}
public bool Update(Entity entity)
{
var queryDoc = new QueryDocument {{EntityIdName, entity.Id}};
var updateDoc = new UpdateDocument {{"$set", SerializeEntity(entity)}};
var result = Collection.Update(queryDoc, updateDoc);
return result.Ok;
}
private void SaveChunk()
{
var lastChunkIndex = (int) ((length + fileInfo.ChunkSize - 1) / fileInfo.ChunkSize) - 1;
if (chunkIndex == -1 || chunkIndex > lastChunkIndex) {
var message = string.Format("Invalid chunk index: {0}", chunkIndex);
throw new MongoGridFSException(message);
}
var lastChunkSize = (int) (length % fileInfo.ChunkSize);
if (lastChunkSize == 0) {
lastChunkSize = fileInfo.ChunkSize;
}
BsonBinaryData data;
if (chunkIndex < lastChunkIndex || lastChunkSize == fileInfo.ChunkSize) {
data = new BsonBinaryData(chunk);
} else {
var lastChunk = new byte[lastChunkSize];
Buffer.BlockCopy(chunk, 0, lastChunk, 0, lastChunkSize);
data = new BsonBinaryData(lastChunk);
}
var query = Query.EQ("_id", chunkId);
var update = new UpdateDocument {
{ "_id", chunkId },
{ "files_id", fileInfo.Id },
{ "n", chunkIndex },
{ "data", data }
};
gridFS.Chunks.Update(query, update, UpdateFlags.Upsert);
chunkIsDirty = false;
}
/// <summary>
/// Modify all documents that match a query
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
protected void QueryModify(ICompiledQuery query, CollectionValue result) {
MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault());
BsonArray conditions = BsonSerializer.Deserialize<BsonArray>(query.Conditions.FirstOrDefault());
BsonArray assignments = BsonSerializer.Deserialize<BsonArray>(query.Assignments.FirstOrDefault());
QueryDocument queryDocument = new QueryDocument(conditions.First().AsBsonDocument);
UpdateDocument updateDocument = new UpdateDocument(assignments.First().AsBsonDocument);
WriteConcernResult writeConcernResult = collection.Update(queryDocument, updateDocument, UpdateFlags.Multi);
result.Add(
new Affected() {
new NumericValue() {
Long = (int)writeConcernResult.DocumentsAffected
}
}
);
}
/// <summary>
/// find and update, with upsert.
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
protected void QueryMerge(ICompiledQuery query, CollectionValue result) {
MongoCollection<BsonDocument> collection = this.Database.GetCollection(query.Collections.FirstOrDefault());
ICompiledQuery save = query.Children.FirstOrDefault(child => child.Root is Save);
ICompiledQuery modify = query.Children.FirstOrDefault(child => child.Root is Modify);
if (save != null && modify != null) {
BsonArray conditions = BsonSerializer.Deserialize<BsonArray>(modify.Conditions.FirstOrDefault());
BsonArray assignments = BsonSerializer.Deserialize<BsonArray>(save.Assignments.FirstOrDefault());
BsonArray sortings = BsonSerializer.Deserialize<BsonArray>(modify.Sortings.FirstOrDefault());
QueryDocument queryDocument = new QueryDocument(conditions.First().AsBsonDocument);
IMongoSortBy sortByDocument = new SortByDocument(sortings.First().AsBsonDocument);
UpdateDocument updateDocument = new UpdateDocument(assignments.First().AsBsonDocument);
FindAndModifyResult findAndModifyResult = collection.FindAndModify(queryDocument, sortByDocument, updateDocument, true, true);
result.Add(this.ToDocument(findAndModifyResult.ModifiedDocument));
}
}
/// <summary>
/// This method stores a order.
/// </summary>
/// <param name="o">The order object to store</param>
/// <returns>Success/Failure</returns>
public Boolean storeOrder(Order o)
{
dLog.Info("Entering method storeOrder | ID: " + o.id);
Boolean result = false;
try
{
MongoServer server = MongoServer.Create();
MongoDatabase db = server.GetDatabase("neatoBurrito");
//MongoCredentials credentials = new MongoCredentials("username", "password");
//MongoDatabase salaries = server.GetDatabase("salaries", credentials);
using (server.RequestStart(db))
{
MongoCollection<BsonDocument> coll = db.GetCollection("order");
var query = new QueryDocument("id", o.id);
dLog.Debug("Finding if order exists");
BsonDocument myDoc = coll.FindOne(query);
query.Add("isComplete", o.isComplete);
query.Add("isSubmitted", o.isSubmitted);
query.Add("orderDate", o.orderDate);
query.Add("totalCost", o.totalCost.ToString());
//ensure we were passed a valid object before attempting to write
if (myDoc == null)
{
dLog.Debug("Inserting order");
coll.Insert(query);
result = true;
}
else
{
var update = new UpdateDocument();
update.Add(query.ToBsonDocument());
dLog.Debug("Updating order");
dLog.Debug("myDoc: " + myDoc.ToString());
dLog.Debug("update Query: " + update.ToString());
SafeModeResult wr = coll.Update(new QueryDocument("id", o.id), update, SafeMode.True);
dLog.Debug("SafeModeResult: " + wr.Ok);
if (wr.LastErrorMessage == null && wr.Ok)
{
result = true;
}
else
{
dLog.Debug("SafeModeResult: " + wr.LastErrorMessage);
}
}
//now insert the burritos
if (result)
{
dLog.Debug("Trying to insert " + o.burritos.Count + " burritos");
var index = 0;
foreach (Burrito b in o.burritos)
{
b.orderID = o.id;
dLog.Debug("Set order ID " + o.id + " for burrito: " + index);
if (b.validate())
{
dLog.Debug("Storing burrito: " + index);
result = burritoSvc.storeBurrito(b);
}
index++;
}
}
}
}
catch (Exception e2)
{
dLog.Error("Exception in storeBurrito: " + e2.Message);
}
finally
{
//using statement above already calls RequestDone()
}
return result;
}
/// <summary>
/// This method stores a user.
/// </summary>
/// <param name="u">The user object to store</param>
/// <returns>Success/Failure</returns>
public Boolean storeUser(User u)
{
dLog.Info("Entering method storeUser | ID: " + u.id);
Boolean result = false;
try
{
MongoServer server = MongoServer.Create();
//MongoCredentials credentials = new MongoCredentials("username", "password");
MongoDatabase db = server.GetDatabase("neatoBurrito");
//MongoDatabase db = server.GetDatabase("neatoBurrito", credentials);
using (server.RequestStart(db))
{
MongoCollection<BsonDocument> coll = db.GetCollection("user");
var query = new QueryDocument("id", u.id);
dLog.Debug("Finding if user exists");
BsonDocument myDoc = coll.FindOne(query);
query.Add("username", u.userName);
query.Add("password", u.password);
//ensure we were passed a valid object before attempting to write
if (myDoc == null)
{
dLog.Debug("Inserting user");
coll.Insert(query);
result = true;
}
else
{
var update = new UpdateDocument();
update.Add(query.ToBsonDocument());
dLog.Debug("Updating user");
dLog.Debug("myDoc: " + myDoc.ToString());
dLog.Debug("update Query: " + update.ToString());
SafeModeResult wr = coll.Update(new QueryDocument("id", u.id), update, SafeMode.True);
dLog.Debug("SafeModeResult: " + wr.Ok);
if (wr.LastErrorMessage == null && wr.Ok)
{
result = true;
}
else
{
dLog.Debug("SafeModeResult: " + wr.LastErrorMessage);
}
}
}
}
catch (Exception e2)
{
dLog.Error("Exception in storeEUser: " + e2.Message);
}
finally
{
//using statement above already calls RequestDone()
}
return result;
}
public string EditVal(int dvid, int ssid, em_SensorType type, DateTime key, string netjson)
{
var coll = DataDV.GetDV().getCol().GetCollection(dvid.ToString() + ssid.ToString() + type.ToString());
DataPointValModel gm;
try
{
gm = BsonSerializer.Deserialize<DataPointValModel>(netjson);
if (!DataDV.GetDV().CheckConnected())
{
return Errors.e7006;
}
var query = Query.EQ("timestamp", key);
gm.timestamp = key;
UpdateDocument update = new UpdateDocument("$set", gm.ToBsonDocument());
coll.Update(query, update, UpdateFlags.Upsert);
return string.Empty;
}
catch
{
return Errors.e7003;
}
}
private void sweep(string transid, string statusfrom, string statusto)
{
IMongoQuery query = Query.And(Query.EQ(Field.Transaction, transid), Query.EQ(Field.Status, statusfrom));
IMongoUpdate update = new UpdateDocument("$set",
new BsonDocument
{
{ Field.Status, statusto }
}
);
collection.Update(query, update, UpdateFlags.Multi);
}
static void Main(string[] args)
{
//这是一个公共的调试默认连接
var client = new MongoClient("mongodb://localhost");
var server = client.GetServer();
var database = server.GetDatabase("foo");
//如果要连接多个服务器，可以直接填写多个服务器名（以及需要的端口号），并且以‘，’分割。如下：
//mongodb://server1,server2:27017,server2:27018
//多数据库服务是模糊不清的，不能分辨服务是否复本集，或者是多数据库服务。drive驱动会跳过connection string的语法检查，
//直接连接进数据库服务器，让server自己检查他们的类别。还有一些办法在连接的时候就指定数据服务器的类别，就是在connection string里面直接描述。如下：
//mongodb://server1,server2:27017,server2:27018/?connect=replicaset
//可用的连接模式包括：automatic (默认), direct, replica set, 以及shardrouter。
//mongodb://server2/?ssl=true(安全链接)
//在默认的情况下，server是通过本地的受信任的证书机构获取许可。在一些测试环境下面，测试server没有签署证书，为了缓解这个情况，
//可以使用在connection string里面添加“sslverifycertificate=false”来屏蔽所有certificate errors（认证错误）。
//Authentication
//MongoDB支持两种认证方式。一种是在程序执行时，调用特定的方法。在执行特定的方法时，认证将会被使用。另外一种健壮的方法是在MongoCredentialsStore存储认证
//使用credential store来确定admin和“foo”数据库的认证信息。除了使用“admin”以及“foo”连接入数据库，还可以使用默认的认证“test”。
//------------------------------------------------------------------------------
var url = new MongoUrl("mongodb://*****:*****@localhost:27017");
var settings = MongoClientSettings.FromUrl(url);
var adminCredentials = new MongoCredentials("admin", "user", true);
var fooCredentials = new MongoCredentials("foo", "user", false);
settings.CredentialsStore.AddCredentials("admin", adminCredentials);
settings.CredentialsStore.AddCredentials("foo", fooCredentials);
var client_1 = new MongoClient(settings);
//------------------------------------------------------------------------------
MongoClient client_2 = new MongoClient(); // connect to localhost
MongoServer server_1 = client_2.GetServer();
MongoDatabase test = server_1.GetDatabase("test");
MongoCredentials credentials = new MongoCredentials("username", "password");
MongoDatabase salaries = server_1.GetDatabase("salaries", credentials);
//------------------------------------------------------------------------------
//大多数的数据库设置从server对象中继承过来，并且提供了GetDatabase的重载。要override其他设置，可以调用CreateDataBaseSetting，在调用GetDataBase之前，改变设置。比如下面这样：
var databaseSettings = server_1.CreateDatabaseSettings("test");
databaseSettings.SlaveOk = true;
var database_1 = server_1.GetDatabase(databaseSettings);
//大多数的collection设置都是继承了collection对象，并且提供了GetCollection的多态性来方便你来重写一些常用的使用设置。
//要重写其他的设置，先调用CreateCollectionSetting来改变设置，然后再调用GetCollection方法。比如下面代码：
//GetCollection维持一个表的实例，如果你再次调用这个GetCollection，它会返回一样的内容。
var collectionSettings = database_1.CreateCollectionSettings<BsonDocument>("test");
collectionSettings.SlaveOk = true;
var collection = database_1.GetCollection(collectionSettings);
//插入函数。插入的对象可以是BsonDocument的实例对象，也可以是任何成功转换成BSON文档的类实例。例如：
MongoCollection<Person> persons_object = database.GetCollection<Person>("Person");
Random r = new Random(BitConverter.ToInt32(Guid.NewGuid().ToByteArray(), 0));
int ages = r.Next(1,100);
string name = CreateSimplifiedChinese(5);
Person p_entity = new Person()
{
name = name,
age = ages,
sex = ages % 2 == 0 ? true : false
};
persons_object.Insert(p_entity);//或者
//persons_object.Insert<Person>(p_entity);
//如果你要插入多重文档，InsertBatch要比Insert有效。
//FindOne以及FindOneAs方法
//要从collection中检索文档，可以使用这个方法。FindOne是最简单的。它会返回结果的第一个文档。例如：
Person p_1 = persons_object.FindOne();
//如果你想检索一个文档，但是它不是<TDefaultDocument>类型的，你需要用到FindOneAs方法。它允许你返回你需要的文档类型。例如：
BsonDocument bson_1 = persons_object.FindOneAs<BsonDocument>();
//Find和FindAs方法是用query语句来告诉服务器返回什么的文档。这个query（查询语句）的类型是IMongoQuery。IMongoQuery是一个标记接口，
//被类识别后可以用来作为查询语言。最常见的方法是，我们可以使用Query创建类或者是QueryDocument类来创建query语句。
//另外如果使用QueryWrapper封装任何类型query语句，query都可以被转变成BSON文档类型。
//使用QueryDocument
var query_1 = new QueryDocument("name", name);
foreach (Person item in persons_object.Find(query_1))
{
Console.WriteLine("QueryDocument:" + item.name);
}
//使用Query Builder
var query_2 = Query.EQ("name",name);
foreach (Person item in persons_object.Find(query_2))
{
Console.WriteLine("Query.EQ:" + item.name);
}
//使用FindAs来获取非默认类型的返回文档
var query_3 = Query<Person>.EQ(x => x.name, name);
foreach (Person item in persons_object.Find(query_3))
{
Console.WriteLine("Query<Person>.EQ:" + item.name);
}
//Save<TDocument>方法
//Save方法是Insert和Update的组合。如果文档的属性是有值的，它会成为Update，来对文档更新。否则将会创建一个新文档调用Insert方法。
//修改性别
var query_4 = Query.And(
Query.EQ("name", "你这个人真是无聊到头顶了")
//,Query.EQ("age",65)
);
Person person_bs1 = persons_object.FindOne(query_4);
if (person_bs1!=null)
{
person_bs1.age = r.Next(1,200);
persons_object.Save(person_bs1);
}
//TDocument必须要有个ID元素，否则你将调用Insert，将文档插入。
//Update方法
var query_5 = Query.And(
Query.EQ("name", "你这个人真是无聊到头顶了")
);
var update_1 = new UpdateDocument {
{"$set",new BsonDocument("age",r.Next(1,200))}
};
WriteConcernResult updateP_1 = persons_object.Update(query_5, update_1);
//FindAndModify方法
//使用FindAndModify方法,你可以在一个原子操作里面查找一个匹配的文档并且修改更新.
//FindAndModify通常用于单个的文档，如果匹配了多个文档，可以使用标准的排序方法匹配到你自己想要修改的文档。
var query_6 = Query.And(Query.EQ("name", "你这个人真是无聊到头顶了"),Query.EQ("sex",true));
var sortby_1 = SortBy.Descending("age");
var update_3 = Update.Set("age", 112).Set("sex", false);
var results_1 = persons_object.FindAndModify(query_6, sortby_1, update_3, true);
var document_1 = results_1.ModifiedDocument;
//MapReduce方法
//Map/Reduce是一种从collection中聚合数据的方法。每个文档（或者使用选择query语句产生的是子集）被发送至map函数，
//map函数会产生一个中间的值。这个中间的值会传送至reduce函数进行数据的聚合。
//下面的例子采集自MongoDB：The Definitive Guide（MongDB权威解析）的87页。它计算在collection中找到的每个key要被计算多少次
//LT=>Less Than
//GT=>More Than
//EQ=>Equels
//IN
var query = Query.And(Query.LT("age", 100), Query.GT("age", 90));
var cursor = persons_object.Find(query);
var firstBook = cursor.FirstOrDefault();
var lastBook = cursor.LastOrDefault();
//Query.All("name", "a", "b");//通过多个元素来匹配数组
//Query.And(Query.EQ("name", "a"), Query.EQ("title", "t"));//同时满足多个条件
//Query.EQ("name", "a");//等于
//Query.Exists("type", true);//判断键值是否存在
//Query.GT("value", 2);//大于>
//Query.GTE("value", 3);//大于等于>=
//Query.In("name", "a", "b");//包括指定的所有值,可以指定不同类型的条件和值
//Query.LT("value", 9);//小于<
//Query.LTE("value", 8);//小于等于<=
//Query.Mod("value", 3, 1);//将查询值除以第一个给定值,若余数等于第二个给定值则返回该结果
//Query.NE("name", "c");//不等于
//Query.Nor(Array);//不包括数组中的值
//Query.Not("name");//元素条件语句
//Query.NotIn("name", "a", 2);//返回与数组中所有条件都不匹配的文档
//Query.Or(Query.EQ("name", "a"), Query.EQ("title", "t"));//满足其中一个条件
//Query.Size("name", 2);//给定键的长度
//Query.Type("_id", BsonType.ObjectId);//给定键的类型
//Query.Where(BsonJavaScript);//执行JavaScript
//Query.Matches("Title", str);//模糊查询 相当于sql中like -- str可包含正则表达式
Console.ReadKey();
}
public void TestUpdateDocumentConstructor()
{
var document1 = new UpdateDocument(dictionary);
var document2 = new UpdateDocument(hashtable);
var document3 = new UpdateDocument(idictionaryNonGeneric);
var document4 = new UpdateDocument(idictionary);
Assert.AreEqual("Dictionary<string, object>", document1["type"].AsString);
Assert.AreEqual("Hashtable", document2["type"].AsString);
Assert.AreEqual("IDictionary", document3["type"].AsString);
Assert.AreEqual("IDictionary<string, object>", document4["type"].AsString);
}
/// <summary>
/// Get a non running message from queue
/// </summary>
/// <param name="query">query where top level fields do not contain operators. Lower level fields can however. eg: valid {a: {$gt: 1}, "b.c": 3}, invalid {$and: [{...}, {...}]}</param>
/// <param name="resetRunning">duration before this message is considered abandoned and will be given with another call to Get()</param>
/// <param name="wait">duration to keep polling before returning null</param>
/// <param name="poll">duration between poll attempts</param>
/// <returns>message or null</returns>
/// <exception cref="ArgumentNullException">query is null</exception>
public BsonDocument Get(QueryDocument query, TimeSpan resetRunning, TimeSpan wait, TimeSpan poll)
{
if (query == null) throw new ArgumentNullException("query");
//reset stuck messages
collection.Update(
new QueryDocument { { "running", true }, { "resetTimestamp", new BsonDocument("$lte", DateTime.UtcNow) } },
new UpdateDocument("$set", new BsonDocument("running", false)),
UpdateFlags.Multi
);
var builtQuery = new QueryDocument("running", false);
foreach (var field in query)
builtQuery.Add("payload." + field.Name, field.Value);
builtQuery.Add("earliestGet", new BsonDocument("$lte", DateTime.UtcNow));
var resetTimestamp = DateTime.UtcNow;
try
{
resetTimestamp += resetRunning;
}
catch (ArgumentOutOfRangeException)
{
resetTimestamp = resetRunning > TimeSpan.Zero ? DateTime.MaxValue : DateTime.MinValue;
}
var sort = new SortByDocument { { "priority", 1 }, { "created", 1 } };
var update = new UpdateDocument("$set", new BsonDocument { { "running", true }, { "resetTimestamp", resetTimestamp } });
var fields = new FieldsDocument("payload", 1);
var end = DateTime.UtcNow;
try
{
end += wait;
}
catch (ArgumentOutOfRangeException)
{
end = wait > TimeSpan.Zero ? DateTime.MaxValue : DateTime.MinValue;
}
while (true)
{
var message = collection.FindAndModify(builtQuery, sort, update, fields, false, false).ModifiedDocument;
if (message != null)
//using merge without overwriting so a possible id in payload doesnt wipe it out the generated one
return new BsonDocument("id", message["_id"]).Merge(message["payload"].AsBsonDocument);
if (DateTime.UtcNow >= end)
return null;
try
{
Thread.Sleep(poll);
}
catch (ArgumentOutOfRangeException)
{
poll = poll < TimeSpan.Zero ? TimeSpan.Zero : TimeSpan.FromMilliseconds(int.MaxValue);
Thread.Sleep(poll);
}
}
}
private void BulkUpdateStatus(string transid, string statusfrom, string statusto)
{
IMongoQuery query = Query.And(Query.EQ(Field.TRANSACTION, transid), Query.EQ(Field.STATE, statusfrom));
IMongoUpdate update = new UpdateDocument("$set",
new BsonDocument
{
{ Field.STATE, statusto }
}
);
collection.Update(query, update, UpdateFlags.Multi);
}
public void TestUpdateChecksThatAllTopLevelFieldNamesAreOperators(bool ordered)
{
_collection.Drop();
var bulk = InitializeBulkOperation(_collection, ordered);
var query = Query.EQ("_id", 1);
var update = new UpdateDocument { { "key", 1 } };
bulk.Find(query).Update(update);
Assert.Throws<BsonSerializationException>(() => bulk.Execute());
}
public void RequestAddFriend(string ownerUsername, string friendUsername, string remark, string groupName, string message,
RequestAddFriendUpdateFlags flags)
{
var db = GetDatabase();
var collection = db.GetCollection("friend_request");
var queryDoc = new QueryDocument();
queryDoc.Add("OwnerUsername", ownerUsername.ToLower());
queryDoc.Add("FriendUsername", friendUsername.ToLower());
var cur = collection.Find(queryDoc);
cur.Limit = 1;
UpdateDocument updateDoc = new UpdateDocument();
if (cur.Size() > 0)
{
foreach (var item in cur)
updateDoc.Add(item);
}
else
{
updateDoc.Add("OwnerUsername", ownerUsername.ToLower());
updateDoc.Add("FriendUsername", friendUsername.ToLower());
}
if (flags == RequestAddFriendUpdateFlags.UpdateAll || (flags & RequestAddFriendUpdateFlags.UpdateRemark) ==
RequestAddFriendUpdateFlags.UpdateRemark)
if (remark == null && updateDoc.Contains("Remark"))
updateDoc.Remove("Remark");
else if (remark != null)
updateDoc.Set("Remark", remark);
if (flags == RequestAddFriendUpdateFlags.UpdateAll || (flags & RequestAddFriendUpdateFlags.UpdateMessage) ==
RequestAddFriendUpdateFlags.UpdateMessage)
if (message == null && updateDoc.Contains("Message"))
updateDoc.Remove("Message");
else if (message != null)
updateDoc.Set("Message", message);
if (flags == RequestAddFriendUpdateFlags.UpdateAll || (flags & RequestAddFriendUpdateFlags.UpdateGroup) ==
RequestAddFriendUpdateFlags.UpdateGroup)
if (groupName == null && updateDoc.Contains("GroupName"))
updateDoc.Remove("GroupName");
else if (groupName != null)
updateDoc.Set("GroupName", groupName);
updateDoc.Set("Time", DateTime.Now);
collection.Update(queryDoc, updateDoc, UpdateFlags.Upsert);
}
/// <summary>
/// This method stores a burrito.
/// </summary>
/// <param name="b">The burrito object to store</param>
/// <returns>Success/Failure</returns>
public Boolean storeBurrito(Burrito b)
{
dLog.Info("Entering method storeBurrito | ID: " + b.id);
Boolean result = false;
try
{
MongoServer server = MongoServer.Create();
MongoDatabase db = server.GetDatabase("neatoBurrito");
//MongoCredentials credentials = new MongoCredentials("username", "password");
//MongoDatabase salaries = server.GetDatabase("salaries", credentials);
using (server.RequestStart(db))
{
MongoCollection<BsonDocument> coll = db.GetCollection("burrito");
var query = new QueryDocument("id", b.id);
dLog.Debug("Finding if burrito exists");
BsonDocument myDoc = coll.FindOne(query);
query.Add("beef", b.Beef);
query.Add("blackBeans", b.BlackBeans);
query.Add("brownRice", b.BrownRice);
query.Add("chicken", b.Chicken);
query.Add("chiliTortilla", b.ChiliTortilla);
query.Add("cucumber", b.Cucumber);
query.Add("flourTortilla", b.FlourTortilla);
query.Add("guacamole", b.Guacamole);
query.Add("herbGarlicTortilla", b.HerbGarlicTortilla);
query.Add("hummus", b.Hummus);
query.Add("jalapenoCheddarTortilla", b.JalapenoCheddarTortilla);
query.Add("jalapenos", b.Jalapenos);
query.Add("lettuce", b.Lettuce);
query.Add("onion", b.Onion);
query.Add("orderID", b.orderID);
query.Add("pintoBeans", b.PintoBeans);
query.Add("price", b.Price.ToString());
query.Add("salsaPico", b.SalsaPico);
query.Add("salsaSpecial", b.SalsaSpecial);
query.Add("salsaVerde", b.SalsaVerde);
query.Add("tomatoBasilTortilla", b.TomatoBasilTortilla);
query.Add("tomatoes", b.Tomatoes);
query.Add("wheatTortilla", b.WheatTortilla);
query.Add("whiteRice", b.WhiteRice);
//ensure we were passed a valid object before attempting to write
if (myDoc == null)
{
dLog.Debug("Inserting burrito");
coll.Insert(query);
result = true;
}
else
{
var update = new UpdateDocument();
update.Add(query.ToBsonDocument());
dLog.Debug("Updating burrito");
dLog.Debug("myDoc: " + myDoc.ToString());
dLog.Debug("update Query: " + update.ToString());
SafeModeResult wr = coll.Update(new QueryDocument("id", b.id), update, SafeMode.True);
dLog.Debug("SafeModeResult: " + wr.Ok);
if (wr.LastErrorMessage == null && wr.Ok)
{
result = true;
}
else
{
dLog.Debug("SafeModeResult: " + wr.LastErrorMessage);
}
}
}
}
catch (Exception e2)
{
dLog.Error("Exception in storeBurrito: " + e2.Message);
}
finally
{
//using statement above already calls RequestDone()
}
return result;
}
/// <summary>
/// Ack message and send payload to queue, atomically.
/// </summary>
/// <param name="message">message to ack received from Get()</param>
/// <param name="payload">payload to send</param>
/// <param name="earliestGet">earliest instant that a call to Get() can return message</param>
/// <param name="priority">priority for order out of Get(). 0 is higher priority than 1</param>
/// <exception cref="ArgumentNullException">message or payload is null</exception>
/// <exception cref="ArgumentException">message id must be a BsonObjectId</exception>
/// <exception cref="ArgumentException">priority was NaN</exception>
public void AckSend(BsonDocument message, BsonDocument payload, DateTime earliestGet, double priority)
{
if (message == null) throw new ArgumentNullException("message");
if (payload == null) throw new ArgumentNullException("payload");
if (Double.IsNaN(priority)) throw new ArgumentException("priority was NaN", "priority");
var messageId = message["id"];
if (messageId.GetType() != typeof(BsonObjectId)) throw new ArgumentException("message id must be a BsonObjectId", "message");
var newMessage = new UpdateDocument
{
{"payload", payload},
{"running", false},
{"resetTimestamp", DateTime.MaxValue},
{"earliestGet", earliestGet},
{"priority", priority},
{"created", DateTime.UtcNow},
};
//using upsert because if no documents found then the doc was removed (SHOULD ONLY HAPPEN BY SOMEONE MANUALLY) so we can just send
collection.Update(new QueryDocument("_id", messageId), newMessage, UpdateFlags.Upsert);
}
private void SaveChunk()
{
var lastChunkIndex = (_length + _fileInfo.ChunkSize - 1) / _fileInfo.ChunkSize - 1;
if (_chunkIndex == -1 || _chunkIndex > lastChunkIndex)
{
var message = string.Format("Invalid chunk index {0}.", _chunkIndex);
throw new MongoGridFSException(message);
}
var lastChunkSize = (int)(_length % _fileInfo.ChunkSize);
if (lastChunkSize == 0)
{
lastChunkSize = _fileInfo.ChunkSize;
}
BsonBinaryData data;
if (_chunkIndex < lastChunkIndex || lastChunkSize == _fileInfo.ChunkSize)
{
data = new BsonBinaryData(_chunk);
}
else
{
var lastChunk = new byte[lastChunkSize];
Buffer.BlockCopy(_chunk, 0, lastChunk, 0, lastChunkSize);
data = new BsonBinaryData(lastChunk);
}
var query = Query.EQ("_id", _chunkId);
var update = new UpdateDocument
{
{ "_id", _chunkId },
{ "files_id", _fileInfo.Id },
{ "n", (_chunkIndex < int.MaxValue) ? (BsonValue)BsonInt32.Create((int)_chunkIndex) : BsonInt64.Create(_chunkIndex) },
{ "data", data }
};
_gridFS.Chunks.Update(query, update, UpdateFlags.Upsert);
_chunkIsDirty = false;
}
