public bool RemoveContact(string id)
{
IMongoQuery query = Query.EQ("_id", id);
SafeModeResult result = _contacts.Remove(query);
return(result.DocumentsAffected == 1);
}
/// <summary>
/// Inserts a new user/role association into the db.
/// </summary>
/// <param name="userRole">The user/role association to add.</param>
/// <returns>true if the user/role is valid and successfully added.</returns>
public bool Insert(UsersInRoles userRole)
{
if (userRole.Validate())
{
userRole.Username = userRole.Username.ToLower();
userRole.Role = userRole.Role.ToLower();
// search for a pre-exisiting association
bool found = (from ur in UserRoles.AsQueryable <UsersInRoles>()
where ur.Username == userRole.Username && ur.Role == userRole.Role
select ur).Any();
if (!found)
{
userRole.UserRoleID = ObjectId.GenerateNewId();
SafeModeResult result = UserRoles.Insert(userRole, SafeMode.True);
return(result.Ok);
}
else
{
return(true);
}
}
else
{
return(false);
}
}
public static void CreateIndex(string connectionString, string databaseName, string collectionName, params string[] keyNames)
{
SafeModeResult result = new SafeModeResult();
if (null == keyNames)
{
return;
}
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
if (!myCollection.IndexExists(keyNames))
{
myCollection.EnsureIndex(keyNames);
}
}
}
void EnsureResultIsGood(SafeModeResult safeModeResult, string message, params object[] objs)
{
if (!safeModeResult.Ok)
{
throw new ApplicationException(string.Format("The following operation didn't suceed: {0}", string.Format(message, objs)));
}
}
/// <summary>
/// Inserts a new user data in the db....isn't being used
/// </summary>
/// <param name="user">User info. to be added</param>
/// <returns>Result of the operation, true if was ok</returns>
public bool Insert(User user)
{
if (user.Validate())
{
SafeModeResult result = Users.Insert(user, SafeMode.True);
return(result.Ok);
}
else
{
return(false);
}
}
public void updateInfo(info _info)
{
IMongoQuery query = Query.EQ("info_id", _info.info_id);
IMongoUpdate update = Update
.Set("firstname", _info.firstname)
.Set("lastname", _info.lastname)
.Set("age", _info.age);
SafeModeResult result = _infos.Update(query, update);
// return result.UpdatedExisting;
}
/// <summary>
/// Updates the info of a webEvent...like a chnage of name, but isn't being used in the app...
/// </summary>
/// <param name="webEvent">WebEvent to be updated</param>
/// <returns>Result of the operation, true if was ok</returns>
public bool Update(WebEvent webEvent)
{
if (webEvent.Validate())
{
SafeModeResult result = WebEvents.Save(webEvent, SafeMode.True);
return(result.Ok);
}
else
{
return(false);
}
}
/// <summary>
/// Inserts a new spot into the db.
/// </summary>
/// <param name="spot">The spot to add.</param>
/// <returns>true if the spot is valid and successfully added.</returns>
public bool Insert(Spot spot)
{
if (spot.Validate())
{
spot.SpotID = ObjectId.GenerateNewId();
SafeModeResult result = Spots.Insert(spot);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Updates the info of a user...like a change of name, but isn't being used in the app...
/// </summary>
/// <param name="user">User to be updated</param>
/// <returns>Result of the operation, true if was ok</returns>
public bool Update(User user)
{
if (user.Validate())
{
user.LastActivityDate = DateTime.UtcNow;
SafeModeResult result = Users.Save(user, SafeMode.True);
return(result.Ok);
}
else
{
return(false);
}
}
/// <summary>
/// Inserts a new role into the db.
/// </summary>
/// <param name="role">The role to add.</param>
/// <returns>true if the role is valid and successfully added.</returns>
public bool Insert(Role role)
{
if (role.Validate())
{
role.RoleID = ObjectId.GenerateNewId();
SafeModeResult result = Roles.Insert(role);
return(true);
}
else
{
return(false);
}
}
public int Update(T instance)
{
int resultCode = 0;
Execute(delegate(MongoCollection <T> mongoCollection)
{
Func <T, string> _getId = new Func <T, string>(GetObjectId);
QueryDocument query = new QueryDocument(new BsonElement("_id", BsonValue.Create(_getId(instance))));
SafeModeResult result = mongoCollection.Update(query,
new UpdateDocument(BsonExtensionMethods.ToBsonDocument <T>(instance)));
resultCode = 1;
});
return(resultCode);
}
public bool UpdateContact(string id, Contact item)
{
IMongoQuery query = Query.EQ("_id", id);
item.LastModified = DateTime.UtcNow;
IMongoUpdate update = Update
.Set("Email", item.Email)
.Set("LastModified", DateTime.UtcNow)
.Set("Name", item.Name)
.Set("Phone", item.Phone);
SafeModeResult result = _contacts.Update(query, update);
return(result.UpdatedExisting);
}
/// <summary>
/// Inserts a new role into the db.
/// </summary>
/// <param name="role">The role to add.</param>
/// <returns>true if the role is valid and successfully added.</returns>
public bool Insert(Parcel parcel)
{
if (parcel.Validate())
{
parcel.ParcelID = ObjectId.GenerateNewId();
SafeModeResult result = Parcels.Insert(parcel);
return(true);
}
else
{
return(false);
}
}
void EnsureResultIsGood(SafeModeResult safeModeResult, string message, int expectedNumberOfAffectedDocuments, params object[] objs)
{
if (!safeModeResult.Ok)
{
var exceptionMessage = string.Format("Tried to {0}, but apparently the operation didn't succeed.",
string.Format(message, objs));
throw new MongoSafeModeException(exceptionMessage, safeModeResult);
}
if (safeModeResult.DocumentsAffected != expectedNumberOfAffectedDocuments)
{
var exceptionMessage = string.Format("Tried to {0}, but documents affected != {1}.",
string.Format(message, objs),
expectedNumberOfAffectedDocuments);
throw new MongoSafeModeException(exceptionMessage, safeModeResult);
}
}
static void Main(string[] args)
{
var connectionString = "mongodb://localhost/?safe=true";
MongoServer server = MongoServer.Create(connectionString);
MongoDatabase database = server.GetDatabase("rastreabilidade");
MongoCollection <BsonDocument> modulo = database.GetCollection <BsonDocument>("modulo");
MongoCollection tabela = database.GetCollection <Tabela>("tabela");
List <Modulo> modulos = new List <Modulo>();
//string name;
string s1 = "TESTEEEEEEEEEEEE"; string s2 = "exemplo1"; string s3 = "exemplo2";
BsonDocument mod = new BsonDocument {
{ "Modulo", s1 }, { "Tabelas", s2 }
};
// modulo.Insert<BsonDocument> (mod);
IMongoQuery query = Query.EQ("Modulo", "fofa=)");
IMongoUpdate update = Update.Set("Modulo", "tata");
SafeModeResult updatedBook = modulo.Update(query, update);
/*foreach (Modulo mod in modulo.FindAll()) {
* name = mod.Nome;
* Console.WriteLine("Nome: ", name);
* modulos.Add(mod);
* Console.WriteLine("Modulo: ", mod);
* }*/
/*var query = Query.EQ("Nome", id);
* entity = collection.FindOne(query);
*
* var update = Update.Set("Name", "Harry");
* collection.Update(query, update);*/
// var query = modulo.AsQueryable<Modulo>().Where(m => m.Nome == "TESTEEEEEEEEEEEE").Select(m => m);
//Console.WriteLine(query);
//Modulo mod = new Modulo { Nome = "TESTEEEEEEEEEEEE"};
//modulo.Insert<Modulo> (mod);
}
public static SafeModeResult InsertOne <T>(string connectionString, string databaseName, string collectionName, T entity)
{
SafeModeResult result = new SafeModeResult();
if (null == entity)
{
return(null);
}
MongoServer server = MongoServer.Create(connectionString);
//获取数据库或者创建数据库（不存在的话）。
MongoDatabase database = server.GetDatabase(databaseName);
using (server.RequestStart(database))//开始连接数据库。
{
MongoCollection <BsonDocument> myCollection = database.GetCollection <BsonDocument>(collectionName);
result = myCollection.Insert(entity);
}
return(result);
}
public bool blnRemoveDocument(string strCollectionName, IMongoQuery query)
{
bool blnReturn = false;
try
{
if (!(string.IsNullOrWhiteSpace(strMongoDataBase)) && !(string.IsNullOrWhiteSpace(strCollectionName)))
{
SafeModeResult objResult = objMdbServer.GetDatabase(strMongoDataBase).GetCollection(strCollectionName).Remove(query, RemoveFlags.Single, SafeMode.True);
blnReturn = objResult.Ok;
}
}
catch (Exception exception)
{
Exception objEx = exception;
blnReturn = false;
clsLog.blnLogError("clsMongoDBEngine", "blnRemoveDocument", "Error Removing Dcoument : ", objEx.ToString());
}
return(blnReturn);
}
/// <summary>
/// This method deletes a burrito.
/// </summary>
/// <param name="id">Unique ID of the burrito to delete</param>
/// <returns>Success/Failure</returns>
public Boolean deleteBurrito(Int32 id)
{
dLog.Info("Entering method deleteBurrito | ID:" + 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", id);
SafeModeResult wr = coll.Remove(query, 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 deleteBurrito: " + e2.Message);
}
finally
{
//using statement above already calls RequestDone()
}
return(result);
}
public int CleanOldData(StoragePath from, TimeSpan savePeriod)
{
int ret = 0;
if (!SupportHistory)
{
throw new NotImplementedException();
}
if (from == null || String.IsNullOrEmpty(from.CategoryPath))
{
foreach (var colname in _db.GetCollectionNames())
{
MongoCollection col = _db.GetCollection(colname);
var q = Query.And(Query.LT("&timings.&actualTill", DateTime.Now - savePeriod));
SafeModeResult smr = col.Remove(q, SafeMode.True);
if (smr != null)
{
if (smr.Ok)
{
ret = (int)smr.DocumentsAffected;
}
else
{
throw new Exception(smr.ErrorMessage);
}
}
else
{
ret = 1;
}
}
}
else if (String.IsNullOrEmpty(from.ObjectId) && String.IsNullOrEmpty(from.QueryString))
{
MongoCollection col = _db.GetCollection(from.CategoryPath);
var q = Query.And(Query.LT("&timings.&actualTill", DateTime.Now - savePeriod));
SafeModeResult smr = col.Remove(q, SafeMode.True);
if (smr != null)
{
if (smr.Ok)
{
ret = (int )smr.DocumentsAffected;
}
else
{
throw new Exception(smr.ErrorMessage);
}
}
else
{
ret = 1;
}
}
else if (String.IsNullOrEmpty(from.ObjectId))
{
MongoCollection col = _db.GetCollection(from.CategoryPath);
BsonDocument bdquery = HelperJsonToBson(from.QueryString);
var q = Query.And(new QueryComplete(bdquery), Query.LT("&timings.&actualTill", DateTime.Now - savePeriod));
SafeModeResult smr = col.Remove(q, SafeMode.True);
if (smr != null)
{
if (smr.Ok)
{
ret = (int)smr.DocumentsAffected;
}
else
{
throw new Exception(smr.ErrorMessage);
}
}
else
{
ret = 1;
}
}
else if (String.IsNullOrEmpty(from.QueryString))
{
throw new InvalidOperationException();
}
else
{
throw new ArgumentException("Storage path can't contain both query string and obid");
}
return(ret);
}
/// <summary>
/// This method stores a employee.
/// </summary>
/// <param name="e">The employee object to store</param>
/// <returns>Success/Failure</returns>
public Boolean storeEmployee(Employee e)
{
dLog.Info("Entering method storeEmployee | ID: " + e.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("employee");
var query = new QueryDocument("id", e.id);
dLog.Debug("Finding if employee exists");
BsonDocument myDoc = coll.FindOne(query);
query.Add("firstName", e.firstName);
query.Add("isManager", e.isManager);
query.Add("lastName", e.lastName);
//ensure we were passed a valid object before attempting to write
if (myDoc == null)
{
dLog.Debug("Inserting employee");
coll.Insert(query);
result = true;
}
else
{
var update = new UpdateDocument();
update.Add(query.ToBsonDocument());
dLog.Debug("Updating employee");
dLog.Debug("myDoc: " + myDoc.ToString());
dLog.Debug("update Query: " + update.ToString());
SafeModeResult wr = coll.Update(new QueryDocument("id", e.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 storeEmployee: " + e2.Message);
}
finally
{
//using statement above already calls RequestDone()
}
return(result);
}
/// <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);
}
public void InsertWebPage(WebPage page)
{
MongoCollection <WebPage> collection = mongo_database.GetCollection <WebPage>("webpages");
SafeModeResult smr = collection.Insert <WebPage>(page);
}
internal SafeModeResult SendMessage(
MongoRequestMessage message,
SafeMode safeMode
)
{
if (state == MongoConnectionState.Closed)
{
throw new InvalidOperationException("Connection is closed");
}
lock (connectionLock) {
message.WriteToBuffer();
CommandDocument safeModeCommand = null;
if (safeMode.Enabled)
{
safeModeCommand = new CommandDocument {
{ "getlasterror", 1 }, // use all lowercase for backward compatibility
{ "fsync", true, safeMode.FSync },
{ "w", safeMode.W, safeMode.W > 1 },
{ "wtimeout", (int)safeMode.WTimeout.TotalMilliseconds, safeMode.W > 1 && safeMode.WTimeout != TimeSpan.Zero }
};
using (
var getLastErrorMessage = new MongoQueryMessage(
message.Server,
"admin.$cmd", // collectionFullName
QueryFlags.None,
0, // numberToSkip
1, // numberToReturn
safeModeCommand,
null, // fields
message.Buffer // piggy back on network transmission for message
)
) {
getLastErrorMessage.WriteToBuffer();
}
}
try {
var networkStream = GetNetworkStream();
networkStream.WriteTimeout = (int)message.Server.Settings.SocketTimeout.TotalMilliseconds;
message.Buffer.WriteTo(networkStream);
messageCounter++;
} catch (Exception ex) {
HandleException(ex);
throw;
}
SafeModeResult safeModeResult = null;
if (safeMode.Enabled)
{
var replyMessage = ReceiveMessage <BsonDocument>(message.Server);
var safeModeResponse = replyMessage.Documents[0];
safeModeResult = new SafeModeResult();
safeModeResult.Initialize(safeModeCommand, safeModeResponse);
if (!safeModeResult.Ok)
{
var errorMessage = string.Format("Safemode detected an error: {0} (response: {1})", safeModeResult.ErrorMessage, safeModeResponse.ToJson());
throw new MongoSafeModeException(errorMessage, safeModeResult);
}
if (safeModeResult.HasLastErrorMessage)
{
var errorMessage = string.Format("Safemode detected an error: {0} (response: {1})", safeModeResult.LastErrorMessage, safeModeResponse.ToJson());
throw new MongoSafeModeException(errorMessage, safeModeResult);
}
}
return(safeModeResult);
}
}
private void btnDelete_Click(object sender, RoutedEventArgs e)
{
IMongoQuery query = Query.EQ("info_id", _info.info_id);
SafeModeResult result = _infos.Remove(query); bindgrid();
}
/// <summary>
/// Removes an item from the database completely.
/// </summary>
/// <param name="itemDefinition">Used to identify the particular item</param>
/// <param name="context"></param>
/// <returns></returns>
public override bool DeleteItem(ItemDefinition itemDefinition, CallContext context)
{
SafeModeResult result = Items.Remove(Query.EQ("_id", itemDefinition.ID.ToGuid()), RemoveFlags.Single, SafeMode);
return(result != null && result.Ok);
}
public bool DeleteAll()
{
SafeModeResult result = WebEvents.RemoveAll();
return(true);
}
public void InsertForwardIndexItem(ForwardIndexItem fitem)
{
MongoCollection <ForwardIndexItem> collection = mongo_database.GetCollection <ForwardIndexItem>("forwardindex");
SafeModeResult smr = collection.Insert <ForwardIndexItem>(fitem);
}
internal SafeModeResult SendMessage(MongoRequestMessage message, SafeMode safeMode)
{
if (_state == MongoConnectionState.Closed)
{
throw new InvalidOperationException("Connection is closed.");
}
lock (_connectionLock)
{
_requestId = message.RequestId;
message.WriteToBuffer();
CommandDocument safeModeCommand = null;
if (safeMode.Enabled)
{
safeModeCommand = new CommandDocument
{
{ "getlasterror", 1 }, // use all lowercase for backward compatibility
{ "fsync", true, safeMode.FSync },
{ "j", true, safeMode.Journal },
{ "w", safeMode.W, safeMode.W > 1 },
{ "w", safeMode.WMode, safeMode.WMode != null },
{ "wtimeout", (int)safeMode.WTimeout.TotalMilliseconds, safeMode.W > 1 && safeMode.WTimeout != TimeSpan.Zero }
};
// piggy back on network transmission for message
using (var getLastErrorMessage = new MongoQueryMessage(message.Buffer, message.WriterSettings, "admin.$cmd", QueryFlags.None, 0, 1, safeModeCommand, null))
{
getLastErrorMessage.WriteToBuffer();
}
}
try
{
var networkStream = GetNetworkStream();
var writeTimeout = (int)_serverInstance.Server.Settings.SocketTimeout.TotalMilliseconds;
if (writeTimeout != 0)
{
networkStream.WriteTimeout = writeTimeout;
}
message.Buffer.WriteTo(networkStream);
_messageCounter++;
}
catch (Exception ex)
{
HandleException(ex);
throw;
}
SafeModeResult safeModeResult = null;
if (safeMode.Enabled)
{
var readerSettings = new BsonBinaryReaderSettings
{
GuidRepresentation = message.WriterSettings.GuidRepresentation,
MaxDocumentSize = _serverInstance.MaxDocumentSize
};
var replyMessage = ReceiveMessage <BsonDocument>(readerSettings, null);
var safeModeResponse = replyMessage.Documents[0];
safeModeResult = new SafeModeResult();
safeModeResult.Initialize(safeModeCommand, safeModeResponse);
if (!safeModeResult.Ok)
{
var errorMessage = string.Format(
"Safemode detected an error '{0}'. (response was {1}).",
safeModeResult.ErrorMessage, safeModeResponse.ToJson());
throw new MongoSafeModeException(errorMessage, safeModeResult);
}
if (safeModeResult.HasLastErrorMessage)
{
var errorMessage = string.Format(
"Safemode detected an error '{0}'. (Response was {1}).",
safeModeResult.LastErrorMessage, safeModeResponse.ToJson());
throw new MongoSafeModeException(errorMessage, safeModeResult);
}
}
return(safeModeResult);
}
}
/// <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);
}
public void InsertInvertedIndexItem(InvertedIndexItem iitem)
{
MongoCollection <InvertedIndexItem> collection = mongo_database.GetCollection <InvertedIndexItem>("invertedindex");
SafeModeResult smr = collection.Insert <InvertedIndexItem>(iitem);
}
