public void CreatingCounters()
{
var context = new RealEstateContext();
var counters = context.Database.GetCollection("counters");
counters.Drop();
var arguments = new FindAndModifyArgs
{
Query = Query.EQ("_id", "apples"),
Update = Update.Inc("counter", 1),
SortBy = SortBy.Null,
VersionReturned = FindAndModifyDocumentVersion.Modified,
Upsert = true
};
var apples = counters.FindAndModify(arguments);
Console.WriteLine("FindAndModify Initialize: " + apples.ModifiedDocument);
arguments.VersionReturned = FindAndModifyDocumentVersion.Original;
apples = counters.FindAndModify(arguments);
Console.WriteLine("FindAndModify (before): " + apples.ModifiedDocument);
arguments.VersionReturned = FindAndModifyDocumentVersion.Modified;
apples = counters.FindAndModify(arguments);
Console.WriteLine("FindAndModify (after): " + apples.ModifiedDocument);
}
public void IncrementOfflineApplicationClickThrough(int vacancyReferenceNumber)
{
_logger.Debug("Calling Mongodb to increment the NoOfOfflineApplicants property by one for vacancy with reference number: {0}", vacancyReferenceNumber);
var args = new FindAndModifyArgs
{
Query = new QueryBuilder <Vacancy>().And(Query <Vacancy> .EQ(d => d.VacancyReferenceNumber, vacancyReferenceNumber), Query <Vacancy> .EQ(d => d.OfflineVacancy, true)),
Update = MongoDB.Driver.Builders.Update.Inc("NoOfOfflineApplicants", 1),
VersionReturned = FindAndModifyDocumentVersion.Modified
};
var result = Collection.FindAndModify(args);
if (result.Ok)
{
_logger.Debug(
"Call to Mongodb to increment the NoOfOfflineApplicants property by one for vacancy with reference number: {0} successfully",
vacancyReferenceNumber);
}
else
{
_logger.Warn(
"Call to Mongodb to increment the NoOfOfflineApplicants property by one for vacancy with reference number: {0} failed: {1}, {2}",
vacancyReferenceNumber, result.Code, result.ErrorMessage);
}
}
public Vacancy ReserveVacancyForQA(int vacancyReferenceNumber)
{
_logger.Debug($"Calling Mongodb to get and reserve vacancy with reference number: {vacancyReferenceNumber} for QA");
var username = Thread.CurrentPrincipal.Identity.Name;
//TODO: Need to check that this number is available for QA via status and/or timeout
//TODO: Possibly further discussion about having code like this in the repo
var args = new FindAndModifyArgs
{
Query = Query <Vacancy> .EQ(d => d.VacancyReferenceNumber, vacancyReferenceNumber),
Update =
MongoDB.Driver.Builders.Update.Set("Status", VacancyStatus.ReservedForQA)
.Set("QAUserName", username)
.Set("DateStartedToQA", DateTime.UtcNow),
SortBy = SortBy.Null,
Upsert = true,
VersionReturned = FindAndModifyDocumentVersion.Modified
};
var result = Collection.FindAndModify(args);
if (result.Ok)
{
_logger.Info($"Called Mongodb to get and reserve vacancy with reference number: {vacancyReferenceNumber} for QA successfully");
var mongoEntity = result.GetModifiedDocumentAs <MongoVacancy>();
return(mongoEntity == null ? null : _mapper.Map <MongoVacancy, Vacancy>(mongoEntity));
}
_logger.Warn($"Call to Mongodb to get and reserve vacancy with reference number: {vacancyReferenceNumber} for QA failed: {result.Code}, {result.ErrorMessage}");
return(null);
}
public async void FindAndModifyAsyncTest1()
{
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", entryMessage1);
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
FindAndModifyArgs findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Upsert = true;
findAndModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
FindAndModifyResult result = await _databaseUpdater.FindAndModifyAsync <Entry>(MONGO_COLLECTION_1_NAME, findAndModifyArgs);
Assert.IsNotNull(result);
Assert.IsTrue(result.Ok);
Assert.IsNull(result.ErrorMessage);
Assert.IsNotNull(result.ModifiedDocument);
results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(MONGO_EDITED_TEXT, results[0].Message);/*This field we modified via FindAndModify...*/
}
public void FindAndModifyTest1()
{
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_readerT.Read(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", entryMessage1);
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
FindAndModifyArgs findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
var findAndModifyResult = _updaterT.FindAndModify(MONGO_COLLECTION_1_NAME, findAndModifyArgs);
Assert.IsTrue(findAndModifyResult.Ok, "FindAndModifyResult from FindAndModify not OK");
Assert.IsNull(findAndModifyResult.ErrorMessage);
Assert.IsNotNull(findAndModifyResult.ModifiedDocument);
results = new List <Entry>(_readerT.Read(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(MONGO_EDITED_TEXT, results[0].Message);/*This field we modified via FindAndModify...*/
}
public override FindAndModifyResult FindAndModify(FindAndModifyArgs args)
{
var sw = new Stopwatch();
sw.Start();
var result = base.FindAndModify(args);
sw.Stop();
var commandStringBuilder = new StringBuilder(1024);
commandStringBuilder.AppendFormat("db.{0}.findAndModify(query, sort, update, new, fields, upsert)", Name);
if (args.Query != null)
{
commandStringBuilder.AppendFormat("\nquery = {0}", args.Query.ToBsonDocument());
}
else
{
commandStringBuilder.Append("\nquery = null");
}
if (args.SortBy != null)
{
commandStringBuilder.AppendFormat("\nsort = {0}", args.SortBy.ToBsonDocument());
}
else
{
commandStringBuilder.Append("\nsort = null");
}
if (args.Update != null)
{
commandStringBuilder.AppendFormat("\nupdate = {0}", args.Update.ToBsonDocument());
}
else
{
commandStringBuilder.Append("\nupdate = null");
}
commandStringBuilder.AppendFormat("\nnew = {0}", args.VersionReturned == FindAndModifyDocumentVersion.Modified ? "true" : "false");
if (args.Fields != null)
{
commandStringBuilder.AppendFormat("\nfields = {0}", args.Fields.ToBsonDocument());
}
else
{
commandStringBuilder.Append("\nfields = null");
}
commandStringBuilder.AppendFormat("\nupsert = {0}", args.Upsert ? "true" : "false");
string commandString = commandStringBuilder.ToString();
ProfilerUtils.AddMongoTiming(commandString, sw.ElapsedMilliseconds, ExecuteType.Update);
return(result);
}
public FindAndModifyResult FindAndModify <T>(IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update)
{
var args = new FindAndModifyArgs {
Query = query, SortBy = sortBy, Update = update
};
return(GetCollection <T>().FindAndModify(args));
}
public void Persist(ICommit commit)
{
var revision = Revision + commit.Events.Count();
if (BucketSize % MaxBucketSize == 0)
{
var bucketNo = _bucketNo + 1;
try
{
_collection.Insert(new BsonDocument
{
{ "StreamId", Id },
{ "StreamRevision", revision },
{ "Commits", new BsonArray {
ToBsonDocument(commit)
} },
{ "BucketSize", 1 },
{ "BucketNo", bucketNo },
});
_bucketNo = bucketNo;
}
catch (MongoDuplicateKeyException)
{
throw new ConcurrencyException();
}
}
else
{
var query = Query.And(
Query.EQ("StreamId", Id),
Query.EQ("BucketNo", BucketNo),
Query.EQ("StreamRevision", Revision)
);
var update = Update
.Set("StreamRevision", revision)
.Push("Commits", ToBsonDocument(commit))
.Inc("BucketSize", 1);
var args = new FindAndModifyArgs
{
Query = query,
Update = update,
};
var result = _collection.FindAndModify(args);
if (result.ModifiedDocument == null)
{
throw new ConcurrencyException();
}
}
_revision = revision;
_bucketSize = BucketSize + 1;
}
public FindAndModifyResult FindAndModify <T>(IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, bool returnNew, bool upsert)
{
var versionReturned = returnNew ? FindAndModifyDocumentVersion.Modified : FindAndModifyDocumentVersion.Original;
var args = new FindAndModifyArgs {
Query = query, SortBy = sortBy, Update = update, VersionReturned = versionReturned, Upsert = upsert
};
return(GetCollection <T>().FindAndModify(args));
}
public long GenerateId()
{
bool lockTaken = false;
try
{
// Entering single-thread block
_lock.Enter(ref lockTaken);
// Incrementing id if it belongs to reserved block
if (_isIdBlockReserved && ++_idBlockOffset < IdBlockLength)
{
return(_idBlockBegin + _idBlockOffset);
}
// Reserving new id block as atomic operation
MongoCollection <SequenceEntity> sequenceCollection = _sequenceRepository.Collection;
IMongoQuery query = Query.EQ("Name", TrackingUrlSequenceName);
IMongoSortBy sortBy = SortBy.Null;
UpdateBuilder update = Update.Inc("Current", IdBlockLength);
var argument = new FindAndModifyArgs {
Query = query, SortBy = sortBy, Update = update, VersionReturned = FindAndModifyDocumentVersion.Modified
};
FindAndModifyResult result = sequenceCollection.FindAndModify(argument);
BsonDocument sequence = result.ModifiedDocument;
if (sequence == null)
{
// first block
_idBlockBegin = 0;
_idBlockOffset = 0;
sequenceCollection.Insert(new SequenceEntity {
Name = TrackingUrlSequenceName, Current = 0
});
}
else
{
_idBlockBegin = sequence.GetValue("Current").AsInt64;
_idBlockOffset = 0;
}
_isIdBlockReserved = true;
long newId = _idBlockBegin + _idBlockOffset;
return(newId);
}
finally
{
if (lockTaken)
{
// Exiting single-thread block
_lock.Exit();
}
}
}
public TimeoutsBatch GetTimeoutsBatch()
{
var retval = new TimeoutsBatch {
DueTimeouts = new List <TimeoutData>()
};
MongoCollection <TimeoutData> collection = _mongoDatabase.GetCollection <TimeoutData>(TimeoutsCollectionName);
DateTime utcNow = DateTime.UtcNow;
// Find all the due timeouts and put a lock on each one to prevent multiple threads/processes getting hold of the same data.
bool doQuery = true;
while (doQuery)
{
var args = new FindAndModifyArgs
{
Query = Query.And(Query.EQ("Locked", false), Query.LTE("Time", utcNow)),
Update = Update <TimeoutData> .Set(c => c.Locked, true),
Upsert = false,
VersionReturned = FindAndModifyDocumentVersion.Original
};
FindAndModifyResult result = collection.FindAndModify(args);
if (result.ModifiedDocument == null)
{
doQuery = false;
}
else
{
retval.DueTimeouts.Add(result.GetModifiedDocumentAs <TimeoutData>());
}
}
// Get next query time
var nextQueryTime = DateTime.MaxValue;
var upcomingTimeoutsRes = collection.Find(Query.GT("Time", utcNow));
foreach (TimeoutData upcomingTimeout in upcomingTimeoutsRes)
{
if (upcomingTimeout.Time < nextQueryTime)
{
nextQueryTime = upcomingTimeout.Time;
}
}
if (nextQueryTime == DateTime.MaxValue)
{
nextQueryTime = utcNow.AddMinutes(1);
}
retval.NextQueryTime = nextQueryTime;
return(retval);
}
public static FindAndModifyResult zFindAndModify(this MongoCollection collection, QueryDocument query, UpdateDocument update, bool upsert = false, SortByWrapper sort = null, FieldsWrapper fields = null)
{
MongoLog.CurrentMongoLog.LogFindAndModify(collection, query, update, upsert, sort, fields);
FindAndModifyArgs args = new FindAndModifyArgs();
args.Query = query;
args.SortBy = sort;
args.Fields = fields;
args.Update = update;
args.Upsert = upsert;
return(MongoLog.CurrentMongoLog.ExecuteAndLogResult(() => collection.FindAndModify(args)));
}
private Counters IncCounter(string counterName)
{
var CountersCollection = mongoDatabase.GetCollection <Counters>(Counters_Col);
var args = new FindAndModifyArgs()
{
Query = Query.Null, SortBy = SortBy.Null, Update = Update.Inc(counterName, 1), Upsert = true
};
FindAndModifyResult counterIncResult = CountersCollection.FindAndModify(args);
Counters updatedCounters = counterIncResult.GetModifiedDocumentAs <Counters>();
return(updatedCounters);
}
void treeListView1_CellEditFinishing(object sender, BrightIdeasSoftware.CellEditEventArgs e)
{
if (e.Cancel)
{
return;
}
if (e.NewValue.Equals(e.Value))
{
return;
}
var node = e.RowObject as ResultTreeNodeModel;
if (node != null && node.IsValue)
{
var convertedValue = node.BsonType.Create(e.NewValue);
if ((convertedValue == null || convertedValue == BsonNull.Value) && node.BsonType != BsonNull.Value)
{
e.Cancel = true;
return;
}
try
{
var parts = node.BsonUpdateQuery.Split(new[] { '.' });
string _id = parts[0];
var collection = _mongoCollectionInfo.GetMongoCollection();
var query = GetIdQuery(_id);
var bDoc = collection.FindOneAs <BsonDocument>(query);
if (bDoc != null)
{
var u = node.BsonUpdateQuery.Substring(node.BsonUpdateQuery.IndexOf('.') + 1);
var update = MongoDB.Driver.Builders.Update.Set(u, convertedValue);
var args = new FindAndModifyArgs {
Query = query, Update = update
};
collection.FindAndModify(args);
node.Value = e.NewValue.ToString();
}
else
{
MessageBox.Show("Unexpected trouble finding document by id.", "Update Failed");
}
}
catch (Exception ex)
{
MessageBox.Show("Failed to update document.\r\n\r\n" + ex.Message, "Update Error");
}
}
}
public async Task <Set> SetFindAndModify(Set set)
{
if (set == null)
{
throw new ArgumentNullException("set");
}
var collection = this.mDatabase.GetCollection <Set>(cSetsCollectionName);
// Query for this set
var cardQuery = Query.And(
Query.EQ("name", set.Name),
Query.EQ("code", set.Code)
);
var setSortBy = SortBy.Descending("name");
// Update document
var setUpdate = Update
.Set("name", set.Name)
.Set("searchName", set.SearchName)
.Set("code", set.Code)
.Set("block", set.Block ?? "")
.Set("type", set.Type ?? "")
.Set("desc", set.Desc ?? "")
.Set("commonQty", set.CommonQty)
.Set("uncommonQty", set.UncommonQty)
.Set("rareQty", set.RareQty)
.Set("mythicQty", set.MythicQty)
.Set("basicLandQty", set.BasicLandQty)
.Set("totalQty", set.TotalQty)
.Set("releasedOn", set.ReleasedOn)
.Set("gathererCode", set.GathererCode ?? "")
.Set("oldCode", set.OldCode ?? "")
.Set("magicCardsInfoCode", set.MagicCardsInfoCode ?? "");
// Find and modify document. If document doesnt exist, insert it
FindAndModifyArgs findModifyArgs = new FindAndModifyArgs();
findModifyArgs.SortBy = setSortBy;
findModifyArgs.Query = cardQuery;
findModifyArgs.Upsert = true;
findModifyArgs.Update = setUpdate;
findModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
var setResult = collection.FindAndModify(findModifyArgs);
var setModified = setResult.GetModifiedDocumentAs <Set>();
return(setModified);
}
private static MongoCollection <BsonDocument> UpdateCapital(MongoDatabase mongoDatabase, string oldName, string newName)
{
MongoCollection <BsonDocument> capitals = mongoDatabase.GetCollection <BsonDocument>("Capital");
FindAndModifyArgs args = new FindAndModifyArgs()
{
Query = Query.EQ("State", oldName),
Update = Update.Set("State", newName),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
FindAndModifyResult res = capitals.FindAndModify(args);
return(capitals);
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
var args = new FindAndModifyArgs();
args.Query = query;
args.SortBy = sortBy;
args.Update = update;
args.Fields = fields;
args.Upsert = upsert;
args.VersionReturned = returnNew ? FindAndModifyDocumentVersion.Modified : FindAndModifyDocumentVersion.Original;
var r = _this.FindAndModify(args);
result = new FindAndModifyUpdateResult(r);
return(r.GetModifiedDocumentAs(documentType));
}
public void FindAndModifyTest3()
{
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", "some message that won't be found by the query");
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
FindAndModifyArgs findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Upsert = true;
findAndModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
_asyncDelegateUpdater.FindAndModifyAsync <Entry>(MONGO_COLLECTION_1_NAME, findAndModifyArgs);
_updaterAutoResetEvent.WaitOne();
Assert.IsTrue(_findAndModifyResult.Ok, "FindAndModifyResult from FindAndModify not OK");
Assert.IsNull(_findAndModifyResult.ErrorMessage);
Assert.IsNotNull(_findAndModifyResult.ModifiedDocument);/*This should be populated as per the last argument to FindAndModify...*/
findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Upsert = false;
_asyncDelegateUpdater.FindAndModifyAsync <Entry>(MONGO_COLLECTION_1_NAME, findAndModifyArgs);
_updaterAutoResetEvent.WaitOne();
Assert.IsTrue(_findAndModifyResult.Ok, "FindAndModifyResult from FindAndModify not OK");
Assert.IsNull(_findAndModifyResult.ErrorMessage);
Assert.IsNull(_findAndModifyResult.ModifiedDocument);/*This should be populated as per the last argument to FindAndModify...*/
results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
}
public CardPrice FindAndModifyCardPrice(CardPrice cardPrice, bool upsert = true)
{
if (cardPrice == null)
{
throw new ArgumentNullException("cardPrice");
}
var cardPriceCollection = this.mDatabase.GetCollection <CardPrice>(cCardPriceCollectionName);
// Query for this card
var cardQuery = Query.And(
Query.EQ("name", cardPrice.Name),
Query.EQ("setCode", cardPrice.SetCode),
Query.EQ("multiverseId", cardPrice.MultiverseId)
);
var cardSoryBy = SortBy.Descending("name");
// Update document
var cardUpdate = Update
.Set("url", cardPrice.Url)
.Set("name", cardPrice.Name)
.Set("searchName", cardPrice.SearchName)
.Set("lastUpdated", cardPrice.LastUpdated)
.Set("setCode", cardPrice.SetCode)
.Set("setCodeAlternate", cardPrice.SetCodeAlternate)
.Set("priceDiff", cardPrice.PriceDiff)
.Set("priceDiffValue", cardPrice.PriceDiffValue)
.Set("priceMid", cardPrice.PriceMid)
.Set("priceLow", cardPrice.PriceLow)
.Set("priceFoil", cardPrice.PriceFoil)
.Set("multiverseId", cardPrice.MultiverseId)
.Set("imageUrl", cardPrice.ImageUrl);
// Find and modify document. If document doesnt exist, insert it
FindAndModifyArgs findModifyArgs = new FindAndModifyArgs();
findModifyArgs.SortBy = cardSoryBy;
findModifyArgs.Query = cardQuery;
findModifyArgs.Upsert = true;
findModifyArgs.Update = cardUpdate;
findModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
var cardResult = cardPriceCollection.FindAndModify(findModifyArgs);
var cardModified = cardResult.GetModifiedDocumentAs <CardPrice>();
return(cardModified);
}
public async void FindAndModifyAsyncTest3()
{
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_collectionReader.Read <Entry>("TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", "some message that won't be found by the query");
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
FindAndModifyArgs findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Upsert = true;
findAndModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
FindAndModifyResult result = await _collectionUpdater.FindAndModifyAsync <Entry>(findAndModifyArgs);
Assert.IsNotNull(result);
Assert.IsTrue(result.Ok);
Assert.IsNull(result.ErrorMessage);
Assert.IsNotNull(result.ModifiedDocument);
findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Upsert = false;
result = await _collectionUpdater.FindAndModifyAsync <Entry>(findAndModifyArgs);
Assert.IsNotNull(result);
Assert.IsTrue(result.Ok);
Assert.IsNull(result.ErrorMessage);
Assert.IsNull(result.ModifiedDocument);
results = new List <Entry>(_collectionReader.Read <Entry>("TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
}
public SetPrice FindAndModifySetPrice(SetPrice setPrice, bool upsert = true)
{
if (setPrice == null)
{
throw new ArgumentNullException("setPrice");
}
var setPriceCollection = this.mDatabase.GetCollection <CardPrice>(cSetPriceCollectionName);
// Query for this set
var setQuery = Query.And(
Query.EQ("name", setPrice.Name),
Query.EQ("setCode", setPrice.SetCode)
);
var cardSoryBy = SortBy.Descending("name");
// Update document
var cardUpdate = Update
.Set("url", setPrice.Url)
.Set("name", setPrice.Name)
.Set("searchName", setPrice.SearchName)
.Set("searchNameAlternate", setPrice.SearchNameAlternate)
.Set("lastUpdated", setPrice.LastUpdated)
.Set("setCode", setPrice.SetCode)
.Set("setCodeAlternate", setPrice.SetCodeAlternate)
.Set("totalCards", setPrice.TotalCards)
.Set("setValue", setPrice.SetValue)
.Set("foilSetValue", setPrice.FoilSetValue);
// Find and modify document. If document doesnt exist, insert it
FindAndModifyArgs findModifyArgs = new FindAndModifyArgs();
findModifyArgs.SortBy = cardSoryBy;
findModifyArgs.Query = setQuery;
findModifyArgs.Upsert = true;
findModifyArgs.Update = cardUpdate;
findModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
var setResult = setPriceCollection.FindAndModify(findModifyArgs);
var setModified = setResult.GetModifiedDocumentAs <SetPrice>();
return(setModified);
}
public string Next(string name)
{
var collection = database.GetCollection(Collection.COUNTERS);
FindAndModifyArgs args = new FindAndModifyArgs();
args.Query = MonQ.Query.EQ("_id", name);
args.Update = MonQ.Update.Inc(Field.COUNTERVALUE, 1);
args.Fields = MonQ.Fields.Include(Field.COUNTERVALUE);
args.Upsert = true;
args.VersionReturned = FindAndModifyDocumentVersion.Modified;
FindAndModifyResult result = collection.FindAndModify(args);
BsonDocument document = result.ModifiedDocument;
string value = document[Field.COUNTERVALUE].AsInt32.ToString();
return(value);
}
public int GetNextVacancyReferenceNumber()
{
_logger.Debug($"Called Mongodb to get next vacancy reference number with Id={VacancyReferenceNumberId}");
var args = new FindAndModifyArgs
{
Query = Query <MongoReferenceNumber> .EQ(d => d.Id, VacancyReferenceNumberId),
Update = Update.Inc("lastReferenceNumber", 1),
SortBy = SortBy.Null,
Upsert = true,
VersionReturned = FindAndModifyDocumentVersion.Modified
};
var result = Collection.FindAndModify(args);
var nextNumber = result.ModifiedDocument.GetValue("lastReferenceNumber").AsInt32;
_logger.Debug($"Called Mongodb to get next vacancy reference number={nextNumber}");
return(nextNumber);
}
public int GetNextLegacyApplicationId()
{
_logger.Debug($"Called Mongodb to get next legacy application id with Id={LegacyApplicationId}");
var args = new FindAndModifyArgs
{
Query = Query <MongoReferenceNumber> .EQ(d => d.Id, LegacyApplicationId),
Update = Update.Inc("lastReferenceNumber", -1),
SortBy = SortBy.Null,
Upsert = true,
VersionReturned = FindAndModifyDocumentVersion.Modified
};
var result = Collection.FindAndModify(args);
var nextId = result.ModifiedDocument.GetValue("lastReferenceNumber").AsInt32;
_logger.Debug($"Called Mongodb to get next legacy application id={nextId}");
return(nextId);
}
public void FindAndModifyTest4()
{
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", entryMessage1);
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
IMongoFields fields = Fields.Include("TimeStamp");
FindAndModifyArgs findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Fields = fields;
findAndModifyArgs.Upsert = true;
findAndModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
_asyncDelegateUpdater.FindAndModifyAsync <Entry>(MONGO_COLLECTION_1_NAME, findAndModifyArgs);
_updaterAutoResetEvent.WaitOne();
Assert.IsTrue(_findAndModifyResult.Ok, "FindAndModifyResult from FindAndModify not OK");
Assert.IsNull(_findAndModifyResult.ErrorMessage);
Assert.IsNotNull(_findAndModifyResult.ModifiedDocument);
results = new List <Entry>(_reader.Read <Entry>(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(MONGO_EDITED_TEXT, results[0].Message);/*This field we modified via FindAndModify...*/
}
public void FindAndModifyTest5()
{
_asyncDelegateUpdater.AsyncFindAndModifyCompleted -= new FindAndModifyCompletedEvent(_updaterAsync_AsyncFindAndModifyCompleted);
string entryMessage1 = "entry 1";
AddMongoEntry(entryMessage1, MONGO_COLLECTION_1_NAME);
List <Entry> results = new List <Entry>(_readerT.Read(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(entryMessage1, results[0].Message);
var searchQuery = Query.EQ("Message", entryMessage1);
var update = Update.Set("Message", MONGO_EDITED_TEXT);
var sortBy = SortBy.Descending("TimeStamp");
IMongoFields fields = Fields.Include("TimeStamp");
FindAndModifyArgs findAndModifyArgs = new FindAndModifyArgs();
findAndModifyArgs.Query = searchQuery;
findAndModifyArgs.SortBy = sortBy;
findAndModifyArgs.Update = update;
findAndModifyArgs.Fields = fields;
findAndModifyArgs.Upsert = true;
findAndModifyArgs.VersionReturned = FindAndModifyDocumentVersion.Modified;
_asyncDelegateUpdater.FindAndModifyAsync <Entry>(MONGO_COLLECTION_1_NAME, findAndModifyArgs);
Thread.Sleep(2000); // wait 2 seconds to show that event handler will not pick up callback
Assert.IsNull(_findAndModifyResult);
results = new List <Entry>(_readerT.Read(MONGO_COLLECTION_1_NAME, "TimeStamp", _beforeTest, DateTime.Now));
Assert.AreEqual(1, results.Count());
Assert.AreEqual(MONGO_EDITED_TEXT, results[0].Message);/*This field we modified via FindAndModify...*/
}
public BsonDocument getDocumentAndModify(string collectionName, FindAndModifyArgs args)
{
//TODO Replace this one
return(new BsonDocument());
}
public static string UpdateOneProduct(string oldProduct, string newProduct, string option)
{
string connectstring1 = "mongodb://*****:*****@ds149433.mlab.com:49433/corevisesdb";
MongoClient client = new MongoClient(connectstring1);
MongoServer ms = client.GetServer();
MongoDatabase db = ms.GetDatabase("corevisesdb");
var collection = db.GetCollection <product>("producto");
FindAndModifyArgs args;
string result = "Hubo un error al actualizar el producto";
switch (option)
{
case "name":
args = new FindAndModifyArgs()
{
Query = Query.EQ("code", oldProduct),
Update = Update.Set("name", newProduct),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
FindAndModifyResult res = collection.FindAndModify(args);
result = "el nombre se actualizo";
break;
case "img":
args = new FindAndModifyArgs()
{
Query = Query.EQ("code", oldProduct),
Update = Update.Set("img", newProduct),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
result = "la imagen se actualizo";
break;
case "price":
args = new FindAndModifyArgs()
{
Query = Query.EQ("code", oldProduct),
Update = Update.Set("price", newProduct),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
result = "el precio se actualizo";
break;
case "stock":
args = new FindAndModifyArgs()
{
Query = Query.EQ("code", oldProduct),
Update = Update.Set("stock", newProduct),
Upsert = false,
SortBy = null,
VersionReturned = FindAndModifyDocumentVersion.Original,
};
result = "stock se actualizo";
break;
default:
Console.WriteLine("Default case");
break;
}
//obtenemos la coleccion en la que vamos a almacenar el objeto
return(result);
}
public FindAndModifyResult FindAndModify <T>(string collectionName, FindAndModifyArgs findAndModifyArgs)
{
var collection = GetCollection <T>(collectionName);
return(collection.FindAndModify(findAndModifyArgs));
}
/// <summary>
/// MongoDb原子操作FindAndModify--
/// </summary>
/// <param name="collectionName"></param>
/// <param name="args"></param>
/// <returns></returns>
public static FindAndModifyResult FindAndModify(string collectionName, FindAndModifyArgs args)
{
return(MongoDbHepler.FindAndModify(nosqlConnectionString, nosqlDbName, collectionName, args));
}
