// public static methods /// <summary> /// Default implementation of the CanCommandBeSentToSecondary delegate. /// </summary> /// <param name="document">The command.</param> /// <returns>True if the command can be sent to a secondary member of a replica set.</returns> public static bool DefaultImplementation(BsonDocument document) { if (document.ElementCount == 0) { return false; } var commandName = document.GetElement(0).Name; if (__secondaryOkCommands.Contains(commandName)) { return true; } if (commandName.Equals("mapreduce", StringComparison.InvariantCultureIgnoreCase)) { BsonValue outValue; if (document.TryGetValue("out", out outValue) && outValue.IsBsonDocument) { return outValue.AsBsonDocument.Contains("inline"); } } return false; }
public void TestBsonDocumentNoId() { _collection.RemoveAll(); var document = new BsonDocument { { "A", 1 } }; _collection.Save(document); Assert.Equal(2, document.ElementCount); Assert.Equal("_id", document.GetElement(0).Name); Assert.IsType<BsonObjectId>(document["_id"]); Assert.NotEqual(ObjectId.Empty, document["_id"].AsObjectId); Assert.Equal(1, _collection.Count()); var id = document["_id"].AsObjectId; document["A"] = 2; _collection.Save(document); Assert.Equal(id, document["_id"].AsObjectId); Assert.Equal(1, _collection.Count()); document = _collection.FindOneAs<BsonDocument>(); Assert.Equal(2, document.ElementCount); Assert.Equal(id, document["_id"].AsObjectId); Assert.Equal(2, document["A"].AsInt32); }
/// <summary> /// 获取Match /// </summary> /// <returns></returns> public BsonDocument GetMatchDocument() { BsonDocument Matchlist = new BsonDocument(); foreach (ctlMatchItem item in this.Controls) { BsonDocument match = item.getMatchItem(); if (match != null) { string MatchName = match.GetElement(0).Name; if (Matchlist.Contains(MatchName)) { BsonDocument AddMatch = match.GetElement(0).Value.AsBsonDocument; Matchlist.GetElement(MatchName).Value.AsBsonDocument.Add(AddMatch); } else { Matchlist.Add(match); } } } if (Matchlist.ElementCount > 0) { return new BsonDocument("$match", Matchlist); } else { return null; } }
public void TestBsonDocumentBsonNullId() { collection.RemoveAll(); var document = new BsonDocument { { "_id", BsonNull.Value }, { "A", 1 } }; collection.Save(document); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual("_id", document.GetElement(0).Name); Assert.IsInstanceOf<BsonObjectId>(document["_id"]); Assert.AreNotEqual(ObjectId.Empty, document["_id"].AsObjectId); Assert.AreEqual(1, collection.Count()); var id = document["_id"].AsObjectId; document["A"] = 2; collection.Save(document); Assert.AreEqual(id, document["_id"].AsObjectId); Assert.AreEqual(1, collection.Count()); document = collection.FindOneAs<BsonDocument>(); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(id, document["_id"].AsObjectId); Assert.AreEqual(2, document["A"].AsInt32); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { string id = document.GetElement(MonthStackStatsRepository.FieldNames.Id).Value.AsString; string[] parts = id.Split('/'); if (parts.Length > 0) return; string errorStackId = parts[0]; var stackCollection = Database.GetCollection(ErrorStackRepository.CollectionName); var errorStack = stackCollection.FindOne(Query.EQ(ErrorStackRepository.FieldNames.Id, new BsonObjectId(new ObjectId(errorStackId)))); if (errorStack != null) { var projectId = errorStack.GetElement(ErrorStackRepository.FieldNames.ProjectId).Value; document.Set(MonthStackStatsRepository.FieldNames.ProjectId, projectId); } document.Set(MonthStackStatsRepository.FieldNames.ErrorStackId, new BsonObjectId(new ObjectId(errorStackId))); var emptyBlocks = new List<BsonElement>(); BsonDocument dayBlocks = document.GetValue(MonthStackStatsRepository.FieldNames.DayStats).AsBsonDocument; foreach (BsonElement b in dayBlocks.Elements) { if (b.Value.AsInt32 == 0) emptyBlocks.Add(b); } foreach (BsonElement b in emptyBlocks) dayBlocks.RemoveElement(b); collection.Save(document); }
public void TestBsonDocumentEmptyGuid() { _collection.RemoveAll(); var document = new BsonDocument { { "_id", Guid.Empty }, { "A", 1 } }; _collection.Save(document); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual("_id", document.GetElement(0).Name); Assert.IsInstanceOf<BsonBinaryData>(document["_id"]); Assert.AreNotEqual(Guid.Empty, document["_id"].AsGuid); Assert.AreEqual(1, _collection.Count()); var id = document["_id"].AsGuid; document["A"] = 2; _collection.Save(document); Assert.AreEqual(id, document["_id"].AsGuid); Assert.AreEqual(1, _collection.Count()); document = _collection.FindOneAs<BsonDocument>(); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(id, document["_id"].AsGuid); Assert.AreEqual(2, document["A"].AsInt32); }
/// <summary> /// 获取Match /// </summary> /// <returns></returns> public BsonDocument GetMatchDocument() { var matchlist = new BsonDocument(); foreach (CtlMatchItem item in Controls) { var match = item.GetMatchItem(); if (match != null) { var matchName = match.GetElement(0).Name; if (matchlist.Contains(matchName)) { var addMatch = match.GetElement(0).Value.AsBsonDocument; matchlist.GetElement(matchName).Value.AsBsonDocument.AddRange(addMatch); } else { matchlist.AddRange(match); } } } if (matchlist.ElementCount > 0) { return new BsonDocument("$match", matchlist); } return null; }
/// <summary> /// 获取Match /// </summary> /// <returns></returns> public BsonDocument GetMatchDocument() { var matchlist = new BsonDocument(); foreach (Control item in Controls) { if (item.GetType().FullName == typeof(Button).FullName) continue; var match = ((CtlMatchItem)item).GetMatchItem(); if (match != null) { var matchName = match.GetElement(0).Name; if (matchlist.Contains(matchName)) { var addMatch = match.GetElement(0).Value.AsBsonDocument; matchlist.GetElement(matchName).Value.AsBsonDocument.AddRange(addMatch); } else { matchlist.AddRange(match); } } } if (matchlist.ElementCount > 0) { return new BsonDocument("$match", matchlist); } return null; }
public static void applyUpdateCommands(BsonDocument doc, BsonDocument change_spec) { foreach (var field in change_spec) { if (field.Name.Length > 0 && field.Name[0] == '$') { // update command switch (field.Name) { case "$set": _applySet(doc, field.Value.AsBsonDocument); break; case "$inc": _applyInc(doc, field.Value.AsBsonDocument); break; case "$unset": _applyUnset(doc, field.Value.AsBsonDocument); break; case "$push": case "$pushAll": case "$addToSet": case "$pop": case "$pull": case "$pullAll": case "$rename": case "$": throw new Exception("unimplemented update operator: " + field.Name); default: throw new Exception("unknown update operator: " + field.Name); } } else { // field replace if (field.Value.BsonType == BsonType.Document) { if (!doc.Contains(field.Name) || doc.GetElement(field.Name).Value.BsonType != BsonType.Document) { // make a document to hold the recurse doc.Set(field.Name, new BsonDocument()); } // recursively apply changes applyUpdateCommands(doc.GetElement(field.Name).Value.AsBsonDocument, field.Value.AsBsonDocument); } else { // otherwise just apply the change directly doc.Set(field.Name, field.Value); } } } }
private void M_Tick(object sender, EventArgs e) { BsonDocument DocStatus = CommandHelper.ExecuteMongoSvrCommand(CommandHelper.serverStatus_Command, SystemManager.GetCurrentServer()).Response; var queryPoint = new DataPoint(); queryPoint.SetValueXY(DateTime.Now.ToString(CultureInfo.InvariantCulture), DocStatus.GetElement("opcounters").Value.AsBsonDocument.GetElement("query").Value); MonitorGrap.Series[0].Points.Add(queryPoint); var insertPoint = new DataPoint(); insertPoint.SetValueXY(DateTime.Now.ToString(CultureInfo.InvariantCulture), DocStatus.GetElement("opcounters").Value.AsBsonDocument.GetElement("insert").Value); MonitorGrap.Series[1].Points.Add(insertPoint); }
public void TestGetHeritageMapTableInformation() { var bson = new BsonDocument(); GetHeritageProjects.GetHeritageMapTableInformation(bson); Console.WriteLine(bson); Assert.IsTrue(bson.ElementCount > 0); Assert.IsTrue(((bson.GetElement(0).Value) as BsonArray).Count == 2); }
/// <summary> /// Parse logLine and extract required data from it /// </summary> /// <param name="logLine"></param> public AccessSessionInfo(BsonDocument logLine) { apache_request_id = logLine.GetValue("request_id").AsString; request_method = logLine.GetValue("request_method").AsString; request_ip = logLine.GetValue("request_ip").AsString; resource = logLine.GetValue("resource").AsString; load_time = logLine.GetValue("request_time").AsString; var offset = logLine.GetElement("ts_offset").Value.ToString(); var timeOffSet = int.Parse(offset); var ts = new System.TimeSpan(timeOffSet / 100, timeOffSet % 100, 0); //convert the current time to UTC var browserStartTime = (DateTime)logLine.GetElement("ts").Value - ts; request_time = browserStartTime.ToUniversalTime(); status_code = logLine.GetValue("status_code").AsString; }
/// <summary> /// Parse explain('executionStats') for non aggregate queries /// </summary> /// <param name="ExplainQuery"></param> /// <returns></returns> public QueryStats GetExplainResultNonAggregate(string ExplainQuery) { BsonDocument QueryExplainResult = _executeQuery(ExplainQuery); string resultjson = QueryExplainResult.GetElement("retval").Value.ToBsonDocument() .GetElement("executionStats").Value.ToJson(); return(JsonConvert.DeserializeObject <QueryStats>(resultjson)); }
private static EncryptedMessageHeaders ReadHeaders(BsonDocument journalEntry) { var headersSubdocument = journalEntry.GetElement("headers").Value.ToBsonDocument(); var headersDict = headersSubdocument.ToDictionary( element => element.Name, element => element.Value.AsString); return(new EncryptedMessageHeaders(headersDict)); }
/// <summary> /// 更新文档 /// </summary> /// <param name="obj"></param> /// <param name="collectionName"></param> /// <param name="updateUser"></param> public static void UpdateDocument(BsonDocument obj, string collectionName, string updateUser = UserSystem) { MongoCollection targetCollection = InnerDefaultDatabase.GetCollection(collectionName); //Remove Old targetCollection.Remove(Query.EQ(MongoKeyField, obj.GetElement(MongoKeyField).Value), WriteConcern.Acknowledged); //Insert New targetCollection.Insert(obj); }
public static Dialogue DecodeDialogue(BsonDocument dialogueDocument, Config config) { string text = dialogueDocument.GetValue("text").AsString; string author = dialogueDocument.GetValue("author").AsString; string sprite = dialogueDocument.GetValue("sprite").AsString; List <Option> options = new List <Option>(); if (dialogueDocument.Contains("options")) { var bsonOptions = dialogueDocument.GetElement("options").Value.AsBsonArray; foreach (var bsonOption in bsonOptions) { var optionDocument = bsonOption.AsBsonDocument; options.Add(DecodeOption(optionDocument.AsBsonDocument)); } } List <PlayerAction> actions = new List <PlayerAction>(); if (dialogueDocument.Contains("actions")) { var bsonActions = dialogueDocument.GetElement("actions").Value.AsBsonArray; foreach (var bsonAction in bsonActions) { var actionDocument = bsonAction.AsBsonDocument; actions.Add(DecodeAction(actionDocument, config.baseItems)); } } List <Substitution> substitutions = new List <Substitution>(); if (dialogueDocument.Contains("substitutions")) { var bsonSubs = dialogueDocument.GetElement("substitutions").Value.AsBsonArray; foreach (var subValue in bsonSubs) { var subDocument = subValue.AsBsonDocument; substitutions.Add(DecodeSubstitution(subDocument, config)); } } return(new Dialogue(text, author, sprite, options.ToArray(), actions.ToArray(), substitutions.ToArray())); }
public void Should_process_a_get_more() { var expectedCommand = new BsonDocument { { "getMore", 20L }, { "collection", MessageHelper.DefaultCollectionNamespace.CollectionName }, { "batchSize", 40 } }; var expectedReplyDocuments = new[] { new BsonDocument("first", 1), new BsonDocument("second", 2) }; var expectedReply = new BsonDocument { { "cursor", new BsonDocument { { "id", expectedCommand["getMore"].ToInt64() }, { "ns", MessageHelper.DefaultCollectionNamespace.FullName }, { "nextBatch", new BsonArray(expectedReplyDocuments) } } }, { "ok", 1 } }; var requestMessage = MessageHelper.BuildGetMore( requestId: 10, cursorId: expectedCommand["getMore"].ToInt64(), batchSize: 40); SendMessages(requestMessage); var replyMessage = MessageHelper.BuildReply <BsonDocument>( expectedReplyDocuments, BsonDocumentSerializer.Instance, responseTo: requestMessage.RequestId, cursorId: expectedReply["cursor"]["id"].ToInt64()); ReceiveMessages(replyMessage); var commandStartedEvent = (CommandStartedEvent)_capturedEvents.Next(); var commandSucceededEvent = (CommandSucceededEvent)_capturedEvents.Next(); commandStartedEvent.CommandName.Should().Be(expectedCommand.GetElement(0).Name); commandStartedEvent.Command.Should().Be(expectedCommand); commandStartedEvent.ConnectionId.Should().Be(_subject.ConnectionId); commandStartedEvent.DatabaseNamespace.Should().Be(MessageHelper.DefaultDatabaseNamespace); commandStartedEvent.OperationId.Should().Be(EventContext.OperationId); commandStartedEvent.RequestId.Should().Be(requestMessage.RequestId); commandSucceededEvent.CommandName.Should().Be(commandStartedEvent.CommandName); commandSucceededEvent.ConnectionId.Should().Be(commandStartedEvent.ConnectionId); commandSucceededEvent.Duration.Should().BeGreaterThan(TimeSpan.Zero); commandSucceededEvent.OperationId.Should().Be(commandStartedEvent.OperationId); commandSucceededEvent.Reply.Should().Be(expectedReply); commandSucceededEvent.RequestId.Should().Be(commandStartedEvent.RequestId); }
/// <summary> /// Insert a new profile, if is set the idProfile, make an update of that idProfile /// </summary> /// <param name="idProfile"> /// Id of the profile to update. /// </param> /// <returns> /// Returns the view to create a new profile /// </returns> public ActionResult newProfile(string idProfile = null) { bool view = false; bool edit = false; bool editClient = false; bool viewClient = false; String dataPermissions = Session["Permissions"].ToString(); String dataPermissionsClient = Session["PermissionsClient"].ToString(); bool access = false; bool accessClient = false; // access = getpermissions("users", "r"); access = validatepermissions.getpermissions("profiles", "c", dataPermissions); accessClient = validatepermissions.getpermissions("profiles", "c", dataPermissionsClient); edit = validatepermissions.getpermissions("profiles", "u", dataPermissions); editClient = validatepermissions.getpermissions("profiles", "u", dataPermissionsClient); view = validatepermissions.getpermissions("profiles", "r", dataPermissions); viewClient = validatepermissions.getpermissions("profiles", "r", dataPermissionsClient); if (idProfile != null && (edit == false || editClient == false)) { access = false; } if (view == false || viewClient == false) { accessClient = false; access = false; } if (access == true && accessClient == true) { CustomFieldsTable cft = new CustomFieldsTable("LocationCustomFields"); String fieldsArray = cft.GetRows(); JArray fields = JsonConvert.DeserializeObject <JArray>(fieldsArray); if (idProfile != null && idProfile != "null" && idProfile != "") { BsonDocument profile = _locationprofileTable.getRow(idProfile); if (profile != null) { profile.Set("_id", profile.GetElement("_id").Value.ToString()); string profileJson = profile.ToJson(); ViewData["profile"] = new HtmlString(profileJson); } } List <BsonDocument> profiles = _locationprofileTable.getRows(); ViewBag.profiles = profiles; return(View(fields)); } else { return(Redirect("~/Home")); } }
/// <summary> /// 插入空文档 /// </summary> /// <param name="mongoCol"></param> /// <param name="safeMode"></param> /// <returns>插入记录的ID</returns> public static BsonValue InsertEmptyDocument(MongoCollection mongoCol, bool safeMode) { var document = new BsonDocument(); if (safeMode) { try { mongoCol.Insert(document, WriteConcern.Acknowledged); return(document.GetElement(ConstMgr.KeyId).Value); } catch { return(BsonNull.Value); } } mongoCol.Insert(document); return(document.GetElement(ConstMgr.KeyId).Value); }
private void UpdateStaffFingerprint(BsonDocument document) { var filter = Builders <BsonDocument> .Filter.Eq("_id", document.GetElement("_id").Value); var update = Builders <BsonDocument> .Update .Set("fingerprint", true) .Set("updatedAt", DateTime.Now); collection.UpdateOne(filter, update); }
public void RenamePropertyFact() { // Arrange var oldName = AutoFixture.String(); var newName = AutoFixture.String(); var value = AutoFixture.String(); var document = new BsonDocument(new BsonElement(oldName, value)); // Act document.RenameProperty(oldName, newName); var @new = document.GetElement(newName); // Assert Action act = () => document.GetElement(oldName); act.ShouldThrow <Exception>(); @new.Should().NotBeNull(); @new.Value.Should().Be(value); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (!document.Contains(ErrorStackRepository.FieldNames.SignatureInfo)) return; var signatureInfo = document.GetElement(ErrorStackRepository.FieldNames.SignatureInfo).Value.AsBsonDocument; bool renamed = signatureInfo.ChangeName("AppPath", "Path"); if (renamed) collection.Save(document); }
private async Task Upsert(ImportTemplate importTemplate, BsonDocument bsonDocument) { var filterDef = Builders <BsonDocument> .Filter.Eq("_id", bsonDocument.GetElement("_id").Value); var collections = _mongoDatabase.GetCollection <BsonDocument>(importTemplate.Schema); await collections.UpdateOneAsync(filterDef, bsonDocument, new UpdateOptions() { IsUpsert = true }); }
/// <summary> /// 插入空文档 /// </summary> /// <param name="mongoCol"></param> /// <returns>插入记录的ID</returns> public static BsonValue InsertEmptyDocument(MongoCollection mongoCol, Boolean safeMode) { var document = new BsonDocument(); if (safeMode) { try { mongoCol.Insert(document, WriteConcern.Acknowledged); return(document.GetElement(KEY_ID).Value); } catch (Exception) { return(BsonNull.Value); } } mongoCol.Insert(document); return(document.GetElement(KEY_ID).Value); }
public override void Save() { Collection = Connection.GetCollection(collectionName); if (_id.CompareTo(new ObjectId()) == 0) { var document = new BsonDocument() { { "Description", Description }, { "Doctor", Doctor.Id }, { "Article", new MongoDBRef("Article", Article._id).ToBsonDocument() }, { "Tags", new BsonArray() }, { "MedicineObjects", new BsonArray() }, { "Changes", new BsonArray() } }; foreach (Tag tag in Tags) { document.GetElement("Tags").Value.AsBsonArray.Add(new MongoDBRef("Tag", tag._id).ToBsonDocument()); } foreach (IEhrObject medicineObject in MedicineObjects) { document.GetElement("MedicineObjects").Value.AsBsonArray.Add(new BsonDocument { { "Table", (medicineObject as SqlEntity).TableName }, { "Id", (medicineObject as SqlEntity).Id } }); } Change change = new Change(); document.GetElement("Changes").Value.AsBsonArray.Add(new BsonDocument { { "ChangeTime", change.ChangeTime }, { "Content", change.Content } }); Collection.InsertOne(document); _id = document.GetValue("_id").AsObjectId; } else { var filter = Builders <BsonDocument> .Filter.Eq("_id", _id); // } }
/// <summary> /// Allows to create or modigy a category /// </summary> /// <param name="jsonString"> /// The category json string with the document's information /// </param> /// <param name="id"> /// The modifying document's id /// </param> /// <author> /// Luis Gonzalo Quijada Romero /// </author> /// <returns> /// Returns the id of the saved document /// </returns> public String saveRow(String jsonString, String id = null) { BsonDocument doc; try //does the jsonString have a json correct format? { doc = BsonDocument.Parse(jsonString); } catch (Exception e) { return(null); } if (id != null && id != "") { doc.Set("_id", new ObjectId(id)); BsonDocument lastData = BsonDocument.Parse(this.getRow(id)); try { doc.Set("CreatedDate", lastData.GetElement("CreatedDate").Value); } catch (Exception e) { doc.Set("CreatedDate", DateTime.Now.ToString()); //if created date is not set let set it to the current date } try { doc.Set("Creator", lastData.GetElement("Creator").Value); } catch (Exception e) { doc.Set("Creator", HttpContext.Current.Session["_id"].ToString()); //if creator is not set let's set it to the current user's id } } else { doc.Set("CreatedDate", DateTime.Now.ToString()); doc.Set("Creator", HttpContext.Current.Session["_id"].ToString()); } doc.Set("LastmodDate", DateTime.Now.ToString()); collection.Save(doc); return(doc["_id"].ToString()); }
public BsonElement GetNextElement() { if (_index < _document.ElementCount) { return(_document.GetElement(_index++)); } else { return(null); } }
private List <BsonDocument> GetFeaturesDocument(IMongoCollection <BsonDocument> featuresCollection, BsonDocument elements) { string brand = elements.GetElement("Maker").Value.ToString().ToLower(), model = elements.GetElement("Model").Value.ToString().ToLower(); var filterBuilder = Builders <BsonDocument> .Filter; var filter = filterBuilder.Eq("Brand", brand) & filterBuilder.Eq("Model", model); var cur = featuresCollection.Find(filter).ToCursor(); List <BsonDocument> returnValue = new List <BsonDocument>(); try { foreach (var doc in cur.ToEnumerable()) { returnValue.Add(doc); } return(returnValue); } catch { return(null); } }
private void AddToAllAFL(BsonDocument doc, int idx) { if (doc != null) { try { Words[idx] = doc.GetElement("words").Value.AsBsonArray.Count; PositiveCount[idx] = doc.GetElement("tone").Value.AsBsonDocument["positiveCount"].AsInt32; } catch (Exception e) { AddToAllAFL(null, idx); } } else { Words[idx] = 0; PositiveCount[idx] = 0; } }
/// <summary> /// Parse explain('executionStats') for aggregate queries /// </summary> /// <param name="ExplainQuery"></param> /// <returns></returns> public QueryStats GetExplainResult(string ExplainQuery) { BsonDocument QueryExplainResult = _executeQuery(ExplainQuery); string resultjson = QueryExplainResult.GetElement("retval").Value.ToBsonDocument() .GetElement("stages").Value.AsBsonArray.First().ToBsonDocument() .GetElement("$cursor").Value.ToBsonDocument() .GetElement("executionStats").Value.ToJson(); return(JsonConvert.DeserializeObject <QueryStats>(resultjson)); }
public ResultModel Update(MetaObject metaObject, FilterDefinition <BsonDocument> condition, BsonDocument bsons) { //错误信息返回值 HashSet <string> ErrorInfo = new HashSet <string>(); if (bsons != null && bsons.Any()) { //获取到字段列表 var metaFields = metaFieldService.GetMetaFieldUpperKeyDicUnDeleted(metaObject.Id); for (int i = bsons.ElementCount - 1; i >= 0; i--) { var item = bsons.GetElement(i); string upperKey = item.Name.ToUpperInvariant(); if (metaFields.ContainsKey(upperKey)) { //检查字段的值是否符合字段类型 var checkResult = metaFieldService.CheckAndGetFieldValueByFieldType(metaFields[upperKey], item.Value); if (checkResult.IsSuccess) { //如果大小写不匹配,则都转化成配置的字段Code形式 if (!item.Name.Equals(metaFields[upperKey].Code)) { bsons.RemoveElement(item); bsons.Add(new BsonElement(metaFields[upperKey].Code, BsonValue.Create(checkResult.Data))); } else { //重置字段的真实类型的值 bsons.SetElement(new BsonElement(metaFields[upperKey].Code, BsonValue.Create(checkResult.Data))); } } else { bsons.RemoveElement(item); ErrorInfo.Add($"字段[{item.Name}]传递的值[{item.Value}]不符合字段定义的类型"); } } else { //如果字段不在配置字段中,则不进行添加 bsons.RemoveElement(item); ErrorInfo.Add($"字段[{item.Name}]不属于对象[{metaObject.Code}({metaObject.Name})]定义的字段"); } } var collection = db.GetCollectionBson(metaObject.Code); var bu = Builders <BsonDocument> .Update; foreach (var item in bsons) { collection.UpdateMany(condition, bu.Set(item.Name, item.Value)); } } return(ResultModel.Success($"修改成功,日志:{string.Join(",", ErrorInfo)}")); }
BsonDocument ExtractVideoFeatures(BsonDocument raw) { var doc = new BsonDocument(); foreach (var feature in selectedFeatures) { if (raw.Names.Contains(feature)) { doc.SetElement(raw.GetElement(feature)); } } // Flatten actorinfo var actorArray = new BsonArray(); var actorDoc = raw.GetValue("actorinfo").AsBsonDocument; foreach (var role in actorDoc.Elements) { foreach (var id in role.Value.AsBsonArray) { actorArray.Add(new BsonDocument { { "role", role.Name }, { "id", id } }); } } doc.Set("actorinfo", actorArray); // Hoist filterinfo var filterinfo = raw.GetValue("filterinfo").AsBsonDocument; foreach (var filter in filterinfoFeatures) { doc.SetElement(filterinfo.GetElement(filter)); } // Extract child video names and desription var childNameArray = new BsonArray(); var childDescArray = new BsonArray(); var children = raw.GetValue("_child").AsBsonArray; foreach (var child in children) { var cd = child.AsBsonDocument; childNameArray.Add(cd.GetValue("sname")); childDescArray.Add(cd.GetValue("storyplot")); } doc.Set("childnames", childNameArray); doc.Set("childplots", childDescArray); return(doc); }
public void Execute(BsonDocument doc) { var occurance = new BsonDocument(doc.GetElement("time"), doc.GetElement("details")); doc.Remove("time"); doc.Remove("details"); var query = Query.And(Query.EQ("token", doc["token"]), Query.EQ("hash", doc["hash"])); UpdateBuilder ub = new UpdateBuilder(); ub.Push("occurances", occurance); ub.Set("token", doc["token"]); ub.Set("hash", doc["hash"]); ub.Set("level", doc["level"]); ub.Set("common", doc["common"]); ub.Set("lastTime", occurance["time"]); Events.Update(query, ub, UpdateFlags.Upsert); }
private static void AddClause(BsonDocument document, BsonElement clause) { if (clause.Name == "$and") { // flatten out nested $and foreach (var item in (BsonArray)clause.Value) { foreach (BsonElement element in (BsonDocument)item) { AddClause(document, element); } } } else if (document.ElementCount == 1 && document.GetElement(0).Name == "$and") { ((BsonArray)document[0]).Add(new BsonDocument(clause)); } else if (document.Contains(clause.Name)) { BsonElement existingClause = document.GetElement(clause.Name); if (existingClause.Value is BsonDocument existingClauseValue && clause.Value is BsonDocument clauseValue) { var clauseOperator = clauseValue.ElementCount > 0 ? clauseValue.GetElement(0).Name : null; if (clauseValue.Names.Any(op => existingClauseValue.Contains(op)) || __operatorsThatCannotBeCombined.Contains(clauseOperator)) { PromoteFilterToDollarForm(document, clause); } else { existingClauseValue.AddRange(clauseValue); } } else { PromoteFilterToDollarForm(document, clause); } }
private void buttonAnterior_Click(object sender, EventArgs e) { if (numCampo == 0) { numCampo = 0; } else { numCampo--; } try { //textBoxCampo.Text = document.GetElement(numCampo).Name.ToString(); textBoxCampo.Text = document.GetElement(numCampo).Name.ToString(); textBoxValor.Text = document.Elements.ElementAt(numCampo).Value.AsString; } catch (Exception) { } labelCampo.Text = "Campo " + (numCampo + 1).ToString(); labelValor.Text = "Valor " + (numCampo + 1).ToString(); }
private void AssertCommandAspect(BsonDocument actualCommand, string name, BsonValue expectedValue) { var commandName = actualCommand.ElementCount == 0 ? "<unknown>" : actualCommand.GetElement(0).Name; if (expectedValue.IsBsonNull) { switch (name) { case "autocommit": case "readConcern": case "recoveryToken": case "startTransaction": case "txnNumber": case "writeConcern": if (actualCommand.Contains(name)) { throw new AssertionFailedException($"Did not expect field '{name}' in command: {actualCommand.ToJson()}."); } return; } } if (!actualCommand.Contains(name)) { // some missing fields are only missing because the C# driver omits default values switch (name) { case "new": if (commandName == "findAndModify" && expectedValue == false) { return; } break; } throw new AssertionFailedException($"Expected field '{name}' in command: {actualCommand.ToJson()}."); } var actualValue = actualCommand[name]; if (name == "updates") { AdaptExpectedUpdateModels(actualValue.AsBsonArray.Cast <BsonDocument>().ToList(), expectedValue.AsBsonArray.Cast <BsonDocument>().ToList()); } var namesToUseOrderInsensitiveComparisonWith = new[] { "writeConcern" }; var useOrderInsensitiveComparison = namesToUseOrderInsensitiveComparisonWith.Contains(name); if (!(useOrderInsensitiveComparison ? BsonValueEquivalencyComparer.Compare(actualValue, expectedValue) : actualValue.Equals(expectedValue))) { throw new AssertionFailedException($"Expected field '{name}' in command '{commandName}' to be {expectedValue.ToJson()} but found {actualValue.ToJson()}."); } }
private void AssertEvent(object actualEvent, BsonDocument expectedEvent) { if (expectedEvent.ElementCount != 1) { throw new FormatException("Expected event must be a document with a single element with a name the specifies the type of the event."); } var eventType = expectedEvent.GetElement(0).Name; var eventAsserter = EventAsserterFactory.CreateAsserter(eventType); eventAsserter.AssertAspects(actualEvent, expectedEvent[0].AsBsonDocument); }
private FindOperation <TResult> CreateAggregateToCollectionFindOperation <TResult>(BsonDocument outStage, IBsonSerializer <TResult> resultSerializer, AggregateOptions options) { CollectionNamespace outputCollectionNamespace; var stageName = outStage.GetElement(0).Name; switch (stageName) { case "$out": { var outputCollectionName = outStage[0].AsString; outputCollectionNamespace = new CollectionNamespace(_databaseNamespace, outputCollectionName); } break; case "$merge": { var mergeArguments = outStage[0].AsBsonDocument; DatabaseNamespace outputDatabaseNamespace; string outputCollectionName; var into = mergeArguments["into"]; if (into.IsString) { outputDatabaseNamespace = _databaseNamespace; outputCollectionName = into.AsString; } else { outputDatabaseNamespace = new DatabaseNamespace(into["db"].AsString); outputCollectionName = into["coll"].AsString; } outputCollectionNamespace = new CollectionNamespace(outputDatabaseNamespace, outputCollectionName); } break; default: throw new ArgumentException($"Unexpected stage name: {stageName}."); } // because auto encryption is not supported for non-collection commands. // So, an error will be thrown in the previous CreateAggregateToCollectionOperation step. // However, since we've added encryption configuration for CreateAggregateToCollectionOperation operation, // it's not superfluous to also add it here var messageEncoderSettings = GetMessageEncoderSettings(); return(new FindOperation <TResult>(outputCollectionNamespace, resultSerializer, messageEncoderSettings) { BatchSize = options.BatchSize, Collation = options.Collation, MaxTime = options.MaxTime, ReadConcern = _settings.ReadConcern, RetryRequested = _client.Settings.RetryReads }); }
public async Task <string> Create(CollectionEnum collection, BsonDocument doc) { SetDate(doc, Const.MODIFIED_ELEMENT, DateTime.Now); var col = mongoDB.GetCollection <BsonDocument>(collection.ToString()); await col.InsertOneAsync(doc); var idElement = doc.GetElement(Const.ID); return(idElement.Value.AsObjectId.ToString()); }
/// <summary> /// This methood allows to change a list's elements /// </summary> /// <param name="ListID"> /// the list's id /// </param> /// <param name="elementName"> /// The element's name which we want to change /// </param> /// <param name="newValue"> /// The value to set to the element /// </param> /// <returns></returns> public String changeElement(String ListID, String elementName, String newValue) { String dataPermissions = Session["Permissions"].ToString(); String dataPermissionsClient = Session["PermissionsClient"].ToString(); bool access = false; bool accessClient = false; // access = getpermissions("users", "r"); access = validatepermissions.getpermissions("lists", "u", dataPermissions); accessClient = validatepermissions.getpermissions("lists", "u", dataPermissionsClient); if (access == true && accessClient == true) { if (this.Request.IsAjaxRequest()) { BsonDocument document = listTable.getRow(ListID); BsonDocument elements = document.GetElement("elements").Value.ToBsonDocument(); BsonArray unorderArray = (BsonArray)elements.GetElement("unorder").Value; foreach (BsonDocument doc in unorderArray) { BsonElement element = doc.First(); if (element.Name == elementName) { element.Value = newValue; String currentDocumentID = document.GetElement("_id").Value.ToString(); document.Remove("_id"); listTable.saveRow(document.ToJson(), currentDocumentID); _logTable.SaveLog(Session["_id"].ToString(), "Listas", "Update: modificar elemento de lista", "List", DateTime.Now.ToString()); return(null); } } } return(null); } else { return(null); } }
private List <string> Compare(BsonDocument first, BsonDocument second) { List <string> changedFields = new List <string>(); foreach (string elementName in first.Names) { BsonElement element = first.GetElement(elementName); if (element.Value.IsBsonDocument) { BsonDocument elementDocument = element.Value.AsBsonDocument; BsonDocument secondElementDocument = second.GetElement(element.Name).Value.AsBsonDocument; if (elementDocument.ElementCount > 1 && secondElementDocument.ElementCount == elementDocument.ElementCount) { foreach (string value in (Compare(elementDocument, secondElementDocument))) { changedFields.Add(value); } } else { changedFields.Add(element.Name); } } else if (element.Value != second.GetElement(element.Name).Value) { changedFields.Add(element.Name); } } return(changedFields); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (!document.Contains(ErrorRepository.FieldNames.RequestInfo)) return; BsonDocument requestInfo = document.GetElement(ErrorRepository.FieldNames.RequestInfo).Value.AsBsonDocument; if (!requestInfo.Contains("frm")) return; requestInfo.Add(ErrorRepository.FieldNames.PostData, new BsonString(requestInfo.GetElement("frm").Value.ToJson())); requestInfo.Remove("frm"); collection.Save(document); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (!document.Contains(ErrorRepository.FieldNames.ExceptionlessClientInfo)) return; BsonDocument clientInfo = document.GetElement(ErrorRepository.FieldNames.ExceptionlessClientInfo).Value.AsBsonDocument; if (clientInfo.Contains("SubmissionMethod")) clientInfo.ChangeName("SubmissionMethod", ErrorRepository.FieldNames.SubmissionMethod); if (clientInfo.Contains(ErrorRepository.FieldNames.InstallDate)) { BsonValue installDateValue = clientInfo.GetElement(ErrorRepository.FieldNames.InstallDate).Value; if (installDateValue.IsBsonArray) return; DateTime installDate = installDateValue.ToUniversalTime(); clientInfo.AsBsonDocument.Set(ErrorRepository.FieldNames.InstallDate, new BsonArray(new BsonValue[] { new BsonInt64(installDate.Ticks), new BsonInt32(-360) })); } collection.Save(document); }
public void TestBsonDocumentGeneratedGuid() { collection.RemoveAll(); var guid = Guid.NewGuid(); var document = new BsonDocument { { "_id", guid }, { "A", 1 } }; collection.Save(document); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual("_id", document.GetElement(0).Name); Assert.IsInstanceOf<BsonBinaryData>(document["_id"]); Assert.AreEqual(guid, document["_id"].AsGuid); Assert.AreEqual(1, collection.Count()); var id = document["_id"].AsGuid; document["A"] = 2; collection.Save(document); Assert.AreEqual(id, document["_id"].AsGuid); Assert.AreEqual(1, collection.Count()); document = collection.FindOneAs<BsonDocument>(); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(id, document["_id"].AsGuid); Assert.AreEqual(2, document["A"].AsInt32); }
public void TestBsonDocumentGeneratedObjectId() { collection.RemoveAll(); var id = ObjectId.GenerateNewId(); var document = new BsonDocument { { "_id", id }, { "A", 1 } }; collection.Save(document); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual("_id", document.GetElement(0).Name); Assert.IsInstanceOf<BsonObjectId>(document["_id"]); Assert.AreEqual(id, document["_id"].AsObjectId); Assert.AreEqual(1, collection.Count()); document["A"] = 2; collection.Save(document); Assert.AreEqual(id, document["_id"].AsObjectId); Assert.AreEqual(1, collection.Count()); document = collection.FindOneAs<BsonDocument>(); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(id, document["_id"].AsObjectId); Assert.AreEqual(2, document["A"].AsInt32); }
public void TestZeroLengthElementName() { var document = new BsonDocument("", "zero length"); Assert.AreEqual(0, document.GetElement(0).Name.Length); }
public void TestConstructorElement() { var element = new BsonElement("x", 1); var document = new BsonDocument(element); Assert.AreEqual(1, document.ElementCount); Assert.AreEqual(1, document["x"].AsInt32); Assert.AreEqual(true, document.Contains("x")); Assert.AreEqual(true, document.ContainsValue(1)); Assert.AreSame(element, document.GetElement("x")); }
public void TestConstructorElements() { var elements = new BsonElement[] { new BsonElement("x", 1), new BsonElement("y", 2) }; var document = new BsonDocument((IEnumerable<BsonElement>)elements); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(1, document["x"].AsInt32); Assert.AreEqual(2, document["y"].AsInt32); Assert.AreEqual(true, document.Contains("x")); Assert.AreEqual(true, document.Contains("y")); Assert.AreEqual(true, document.ContainsValue(1)); Assert.AreEqual(true, document.ContainsValue(2)); Assert.AreSame(elements[0], document.GetElement("x")); Assert.AreSame(elements[1], document.GetElement("y")); }
private static void AssertTimestampLogged(BsonDocument doc) { var now = DateTime.UtcNow; var oneSecondAgo = now.AddSeconds(-1); doc.GetElement("timestamp").Value.ToUniversalTime().Should().Be.IncludedIn(oneSecondAgo, now); }
public void TestInsertAt() { var document = new BsonDocument(); document.InsertAt(0, new BsonElement("x", 1)); Assert.AreEqual("x", document.GetElement(0).Name); Assert.AreEqual(1, document[0].AsInt32); document.InsertAt(0, new BsonElement("y", 2)); Assert.AreEqual("y", document.GetElement(0).Name); Assert.AreEqual(2, document[0].AsInt32); Assert.AreEqual("x", document.GetElement(1).Name); Assert.AreEqual(1, document[1].AsInt32); }
/// <summary> /// Parses and returns the status from a replSetGetStatus result. /// </summary> private static ReplicaSetStatus ParseStatus(BsonDocument response) { // See if starting up... BsonValue startupStatus; if (response.TryGetValue("startupStatus", out startupStatus)) { return new ReplicaSetStatus { Status = State.Initializing }; } // Otherwise, extract the servers... return new ReplicaSetStatus { Status = State.OK, ReplicaSetName = response.GetValue("set").AsString, Servers = ServerStatus.Parse(response.GetElement("members").Value.AsBsonArray) }; }
// private static methods // try to keey the query in simple form and only promote to $and form if necessary private static void AddAndClause(BsonDocument query, BsonElement clause) { if (query.ElementCount == 1 && query.GetElement(0).Name == "$and") { query[0].AsBsonArray.Add(new BsonDocument(clause)); } else { if (clause.Name == "$and") { PromoteQueryToDollarAndForm(query, clause); } else { if (query.Contains(clause.Name)) { var existingClause = query.GetElement(clause.Name); if (existingClause.Value.IsBsonDocument && clause.Value.IsBsonDocument) { var clauseValue = clause.Value.AsBsonDocument; var existingClauseValue = existingClause.Value.AsBsonDocument; if (clauseValue.Names.Any(op => existingClauseValue.Contains(op))) { PromoteQueryToDollarAndForm(query, clause); } else { foreach (var element in clauseValue) { existingClauseValue.Add(element); } } } else { PromoteQueryToDollarAndForm(query, clause); } } else { query.Add(clause); } } } }
public void TestConstructorElementsDocument() { var originalDocument = new BsonDocument { { "x", 1 }, { "y", 2 } }; var document = new BsonDocument(originalDocument); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(1, document["x"].AsInt32); Assert.AreEqual(2, document["y"].AsInt32); Assert.AreEqual(true, document.Contains("x")); Assert.AreEqual(true, document.Contains("y")); Assert.AreEqual(true, document.ContainsValue(1)); Assert.AreEqual(true, document.ContainsValue(2)); Assert.AreSame(originalDocument.GetElement("x"), document.GetElement("x")); Assert.AreSame(originalDocument.GetElement("y"), document.GetElement("y")); }
public void TestSetElementReplaceElement() { var document = new BsonDocument("x", 1); var element = new BsonElement("x", 2); document.SetElement(element); Assert.AreEqual(1, document.ElementCount); Assert.AreEqual("x", document.GetElement(0).Name); Assert.AreEqual(2, document["x"].AsInt32); }
public void TestSetDocumentIdNewElement() { var document = new BsonDocument("x", 1); ((IBsonIdProvider)BsonDocumentSerializer.Instance).SetDocumentId(document, BsonValue.Create(2)); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual("_id", document.GetElement(0).Name); Assert.AreEqual(2, document["_id"].AsInt32); }
public void TestRemoveElement() { var document = new BsonDocument { { "x", 1 }, { "y", 2 } }; Assert.AreEqual(2, document.ElementCount); document.RemoveElement(document.GetElement(0)); Assert.AreEqual(1, document.ElementCount); Assert.AreEqual(2, document["y"].AsInt32); }
public void TestBsonDocumentStringId() { collection.RemoveAll(); var id = "123"; var document = new BsonDocument { { "_id", id }, { "A", 1 } }; collection.Save(document); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual("_id", document.GetElement(0).Name); Assert.IsInstanceOf<BsonString>(document["_id"]); Assert.AreEqual(id, document["_id"].AsString); Assert.AreEqual(1, collection.Count()); document["A"] = 2; collection.Save(document); Assert.AreEqual(id, document["_id"].AsString); Assert.AreEqual(1, collection.Count()); document = collection.FindOneAs<BsonDocument>(); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(id, document["_id"].AsString); Assert.AreEqual(2, document["A"].AsInt32); }
/** \fn void AttachCollection (string subClFullName, BsonDocument options) * \brief Attach the specified collection. * \param subClFullName The name of the subcollection * \param options The low boudary and up boudary * eg: {"LowBound":{a:1},"UpBound":{a:100}} * \retval void * \exception SequoiaDB.BaseException * \exception System.Exception */ public void AttachCollection(string subClFullName, BsonDocument options) { // check argument if (subClFullName == null || subClFullName.Equals("") || subClFullName.Length > SequoiadbConstants.COLLECTION_MAX_SZ || options == null || options.ElementCount == 0) { throw new BaseException("SDB_INVALIDARG"); } // build a bson to send BsonDocument attObj = new BsonDocument(); attObj.Add(SequoiadbConstants.FIELD_NAME, collectionFullName); attObj.Add(SequoiadbConstants.FIELD_SUBCLNAME, subClFullName); foreach (string key in options.Names) { attObj.Add(options.GetElement(key)); } // build commond string commandString = SequoiadbConstants.ADMIN_PROMPT + SequoiadbConstants.LINK_CL; BsonDocument dummyObj = new BsonDocument(); SDBMessage rtnSDBMessage = AdminCommand(commandString, attObj, dummyObj, dummyObj, dummyObj, 0, -1, 0); // check the return flag int flags = rtnSDBMessage.Flags; if (flags != 0) throw new BaseException(flags); }
public void TestBsonDocumentInt64Id() { _collection.RemoveAll(); var id = 123L; var document = new BsonDocument { { "_id", id }, { "A", 1 } }; _collection.Save(document); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual("_id", document.GetElement(0).Name); Assert.IsInstanceOf<BsonInt64>(document["_id"]); Assert.AreEqual(id, document["_id"].AsInt64); Assert.AreEqual(1, _collection.Count()); document["A"] = 2; _collection.Save(document); Assert.AreEqual(id, document["_id"].AsInt64); Assert.AreEqual(1, _collection.Count()); document = _collection.FindOneAs<BsonDocument>(); Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(id, document["_id"].AsInt64); Assert.AreEqual(2, document["A"].AsInt32); }
public void TestConstructorElementsParams() { var element1 = new BsonElement("x", 1); var element2 = new BsonElement("y", 2); #pragma warning disable 618 var document = new BsonDocument(element1, element2); #pragma warning restore Assert.AreEqual(2, document.ElementCount); Assert.AreEqual(1, document["x"].AsInt32); Assert.AreEqual(2, document["y"].AsInt32); Assert.AreEqual(true, document.Contains("x")); Assert.AreEqual(true, document.Contains("y")); Assert.AreEqual(true, document.ContainsValue(1)); Assert.AreEqual(true, document.ContainsValue(2)); Assert.AreSame(element1, document.GetElement("x")); Assert.AreSame(element2, document.GetElement("y")); }