public GeneralTrigger(BsonDocument doc, TriggerType triggerType) { TriggerOn = new List<string>(); And = new List<string>(); NotOn = new List<string>(); MessageOverrideAsString = new List<string>(); if (doc != null && doc.ElementCount > 0 && doc.Contains("TriggerOn")) { foreach (var on in doc["TriggerOn"].AsBsonArray) { TriggerOn.Add(on.AsString); } foreach (var and in doc["And"].AsBsonArray) { And.Add(and.AsString); } foreach (var not in doc["NoTriggerOn"].AsBsonArray) { NotOn.Add(not.AsString); } AutoProcess = doc.Contains("AutoProcess") ? doc["AutoProcess"].AsBoolean : false; ChanceToTrigger = doc["ChanceToTrigger"].AsInt32; script = ScriptFactory.GetScript(doc["ScriptID"].AsString, triggerType.ToString()); foreach (var overrides in doc["Overrides"].AsBsonArray) { MessageOverrideAsString.Add(overrides.AsString); } Type = doc["Type"].AsString; TriggerId = doc["Id"].AsString; } }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { decimal price = 0m; if (!document.Contains(OrganizationRepository.FieldNames.PlanId)) return; switch (document.GetValue(OrganizationRepository.FieldNames.PlanId).AsString) { case "EX_SMALL": price = BillingManager.SmallPlan.Price; break; case "EX_MEDIUM": price = BillingManager.MediumPlan.Price; break; case "EX_LARGE": price = BillingManager.LargePlan.Price; break; } if (price == 0m) return; if (!document.Contains(OrganizationRepository.FieldNames.BillingPrice)) document.Add(OrganizationRepository.FieldNames.BillingPrice, new BsonString(price.ToString())); else document.Set(OrganizationRepository.FieldNames.BillingPrice, new BsonString(price.ToString())); collection.Save(document); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (document.Contains("ErrorCount")) document.ChangeName("ErrorCount", "EventCount"); if (document.Contains("TotalErrorCount")) document.ChangeName("TotalErrorCount", "TotalEventCount"); if (document.Contains("LastErrorDate")) document.ChangeName("LastErrorDate", "LastEventDate"); if (document.Contains("MaxErrorsPerMonth")) document.ChangeName("MaxErrorsPerMonth", "MaxEventsPerMonth"); if (document.Contains("SuspensionCode")) { var value = document.GetValue("SuspensionCode"); document.Remove("SuspensionCode"); SuspensionCode suspensionCode; if (value.IsString && Enum.TryParse(value.AsString, true, out suspensionCode)) document.Set("SuspensionCode", suspensionCode); } collection.Save(document); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (document.Contains("OverageHours")) document.Remove("OverageHours"); if (document.Contains("Usage")) document.Remove("Usage"); collection.Save(document); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (document.Contains("MaxErrors")) document.Remove("MaxErrors"); if (document.Contains("MaxErrorsPerStack")) document.Remove("MaxErrorsPerStack"); collection.Save(document); }
public void InsertOneBsonDocument() { var bsonDocument = new BsonDocument() { {"Name","Mehmet Çakır"}, {"Email","*****@*****.**"} }; bsonDocument.Contains("_id").Should().BeFalse(); Func<Task> act = () => BlogContext.UserAsBson.InsertOneAsync(bsonDocument); act.ShouldNotThrow(); bsonDocument.Contains("_id").Should().BeTrue(); bsonDocument["_id"].Should().NotBe(ObjectId.Empty); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (document.Contains("OverageDays")) document.Remove("OverageDays"); if (document.Contains("MaxErrorsPerDay")) { document.ChangeName("MaxErrorsPerDay", "MaxErrorsPerMonth"); var maxErrorsPerMonth = document.GetValue("MaxErrorsPerMonth").AsInt32; if (maxErrorsPerMonth > 0) document.Set("MaxErrorsPerMonth", maxErrorsPerMonth * 30); } collection.Save(document); }
/// <summary> /// /// </summary> /// <param name="document"></param> /// <returns></returns> private UpdateFlags GetUpdateFlags(BsonDocument document) { var flags = UpdateFlags.None; if (document.Contains("upsert")) { flags = flags | ((document["upsert"].ToBoolean()) ? (UpdateFlags.Upsert) : (UpdateFlags.None)); } if (document.Contains("multi")) { flags = flags | ((document["multi"].ToBoolean()) ? (UpdateFlags.Upsert) : (UpdateFlags.None)); } return flags; }
// constructors /// <summary> /// Initializes a new instance of the <see cref="AggregateResult" /> class. /// </summary> /// <param name="response">The response.</param> public AggregateResult(BsonDocument response) : base(response) { if (response.Contains("cursor")) { var cursorDocument = response["cursor"]; _cursorId = cursorDocument["id"].ToInt64(); _resultDocuments = cursorDocument["firstBatch"].AsBsonArray.Select(v => v.AsBsonDocument); } if (response.Contains("result")) { _resultDocuments = response["result"].AsBsonArray.Select(v => v.AsBsonDocument); } }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (document.Contains("OrganizationId")) document.ChangeName("OrganizationId", "oid"); if (document.Contains("ProjectId")) document.ChangeName("ProjectId", "pid"); if (document.Contains("Version")) document.Remove("Version"); document.Set("Version", "1.0.0.0"); collection.Save(document); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (!document.Contains(OrganizationRepository.FieldNames.PlanId)) return; string planId = document.GetValue(OrganizationRepository.FieldNames.PlanId).AsString; if (String.IsNullOrEmpty(planId) || !String.Equals(planId, BillingManager.FreePlan.Id)) return; if (!document.Contains(OrganizationRepository.FieldNames.RetentionDays)) document.Add(OrganizationRepository.FieldNames.RetentionDays, new BsonInt64(BillingManager.FreePlan.RetentionDays)); else document.Set(OrganizationRepository.FieldNames.RetentionDays, new BsonInt64(BillingManager.FreePlan.RetentionDays)); collection.Save(document); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { ObjectId organizationId = document.GetValue(ProjectRepository.FieldNames.OrganizationId).AsObjectId; var users = Database.GetCollection(UserRepository.CollectionName) .Find(Query.In(UserRepository.FieldNames.OrganizationIds, new List<BsonValue> { organizationId })) .SetFields(ProjectRepository.FieldNames.Id).ToList(); if (!document.Contains(ProjectRepository.FieldNames.NotificationSettings)) document.Add(ProjectRepository.FieldNames.NotificationSettings, new BsonDocument()); BsonDocument settings = document.GetValue(ProjectRepository.FieldNames.NotificationSettings).AsBsonDocument; foreach (var user in users) { var userId = user.GetValue(ProjectRepository.FieldNames.Id).AsObjectId.ToString(); if (!settings.Contains(userId)) settings.Add(userId, new BsonDocument()); var userSettings = settings.GetValue(userId).AsBsonDocument; if (!userSettings.Contains("SendDailySummary")) userSettings.Add("SendDailySummary", new BsonBoolean(true)); else userSettings.Set("SendDailySummary", new BsonBoolean(true)); } collection.Save(document); }
public static long GetInt64(BsonDocument doc, string propertyName) { long result = 0; if (doc.Contains(propertyName)) result = doc[propertyName].AsInt64; return result; }
/// <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; }
public static Guid GetGuid(BsonDocument doc, string propertyName) { Guid result = Guid.Empty; if (doc.Contains(propertyName)) result = new Guid(doc[propertyName].AsByteArray); return result; }
public static int GetInt32(BsonDocument doc, string propertyName) { int result = 0; if (doc.Contains(propertyName)) result = doc[propertyName].AsInt32; return result; }
public static bool GetBoolean(BsonDocument doc, string propertyName) { bool result = false; if (doc.Contains(propertyName)) result = doc[propertyName].AsBoolean; return result; }
public static DateTime GetDateTime(BsonDocument doc, string propertyName) { DateTime result = DateTime.MinValue; if (doc.Contains(propertyName)) result = doc[propertyName].ToUniversalTime(); return result; }
/// <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 BsonArray GetArray(BsonDocument doc, string propertyName) { BsonArray result = null; if (doc.Contains(propertyName)) result = doc[propertyName].AsBsonArray; return result; }
/// <summary> /// Combines subqueries with an and operator. /// </summary> /// <param name="queries">The subqueries.</param> /// <returns>The builder (so method calls can be chained).</returns> public static QueryComplete And( params QueryComplete[] queries ) { var document = new BsonDocument(); foreach (var query in queries) { foreach (var queryElement in query.ToBsonDocument()) { // if result document has existing operations for same field append the new ones if (document.Contains(queryElement.Name)) { var existingOperations = document[queryElement.Name] as BsonDocument; var newOperations = queryElement.Value as BsonDocument; // make sure that no conditions are Query.EQ, because duplicates aren't allowed if (existingOperations == null || newOperations == null) { var message = string.Format("Query.And does not support combining equality comparisons with other operators (field: '{0}')", queryElement.Name); throw new InvalidOperationException(message); } // add each new operation to the existing operations foreach (var operation in newOperations) { // make sure that there are no duplicate $operators if (existingOperations.Contains(operation.Name)) { var message = string.Format("Query.And does not support using the same operator more than once (field: '{0}', operator: '{1}')", queryElement.Name, operation.Name); throw new InvalidOperationException(message); } else { existingOperations.Add(operation); } } } else { document.Add(queryElement); } } } return new QueryComplete(document); }
public static BsonDocument ToBsonDocument(this XElement xElement) { var bsonDocument = new BsonDocument(); var type = xElement.Name.ToString(); bsonDocument.Add(Constants._TYPE, type); var mainId = xElement.Attribute(Constants._ID) != null ? xElement.Attribute(Constants._ID).Value : null; foreach (XAttribute attribure in xElement.Attributes()) { var key = attribure.Name.ToString(); var value = attribure.Value; if (bsonDocument.Contains(key)) bsonDocument.Set(key, value); else bsonDocument.Add(key, value); } foreach (XElement kid in xElement.Descendants()) { var id = kid.Attribute(Constants._ID); if (id == null || mainId == null) { bsonDocument.Add(kid.Name.ToString(), kid.ToBsonDocument()); } else { kid.SetAttributeValue(Constants.PARENT_ID, mainId); DBFactory.GetData().Save(kid); } } return bsonDocument; }
/// <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; } }
private static IEnumerable<BsonElement> ProcessFields(this BsonDocument a, BsonDocument b) { return from e in a.Where(e => b.Contains(e.Name)) let d = Diff(e.Value, b[e.Name]) where d.ElementCount > 0 select new BsonElement(e.Name, d); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (document.Contains("EmailNotificationsEnabled")) { bool emailNotificationsEnabled = document.GetValue("EmailNotificationsEnabled").AsBoolean; while (document.Contains("EmailNotificationsEnabled")) document.Remove("EmailNotificationsEnabled"); document.Set("EmailNotificationsEnabled", emailNotificationsEnabled); } if (document.Contains("EmailAddress")) { string emailAddress = document.GetValue("EmailAddress").AsString; if (!String.IsNullOrWhiteSpace(emailAddress)) document.Set("EmailAddress", emailAddress.ToLowerInvariant().Trim()); } collection.Save(document); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (!document.Contains(UserRepository.FieldNames.IsEmailAddressVerified)) document.Add(UserRepository.FieldNames.IsEmailAddressVerified, new BsonBoolean(true)); else document.Set(UserRepository.FieldNames.IsEmailAddressVerified, new BsonBoolean(true)); collection.Save(document); }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (collection.IndexExistsByName("Username_1")) collection.DropIndexByName("Username_1"); if (document.Contains("Username")) document.Remove("Username"); collection.Save(document); }
/// <summary> /// /// </summary> /// <param name="document"></param> static public MailItem BsonDocumentToMailItem(BsonDocument document) { var mailitem = new MailItem(); if (document.Contains("_id"))mailitem.Id = document["_id"].ToString(); if (document.Contains("text"))mailitem.Text = document["text"].AsString; if (document.Contains("time"))mailitem.Time = document["time"].ToLocalTime(); if (document.Contains("form"))mailitem.FormCode = document["form"].AsString; if (document.Contains("year"))mailitem.Year = document["year"].AsInt32; if (document.Contains("period"))mailitem.Period = document["period"].AsInt32; if (document.Contains("obj"))mailitem.ObjId = document["obj"].AsInt32; if (document.Contains("user"))mailitem.User = document["user"].AsString; if (document.Contains("type"))mailitem.Type = document["type"].AsString; TestItem = mailitem; return mailitem; }
private List<string> ParseMembers(BsonDocument document) { if(document == null || !document.Contains("teamMemberIds")) { return new List<string>(); } var teamMemberIds = document["teamMemberIds"].AsBsonArray; return teamMemberIds.Select(i => GetStringValue(i, "userId")).ToList(); }
public static bool GetBoolean(BsonDocument doc, string propertyName) { bool result = false; if (doc.Contains(propertyName)) { result = doc[propertyName].AsBoolean; } return(result); }
public static BsonArray GetArray(BsonDocument doc, string propertyName) { BsonArray result = null; if (doc.Contains(propertyName)) { result = doc[propertyName].AsBsonArray; } return(result); }
public static long?GetLong(BsonDocument doc, string propertyName) { long?result = null; if (doc.Contains(propertyName)) { result = doc[propertyName].AsInt64; } return(result); }
public static DateTime GetDateTime(BsonDocument doc, string propertyName) { DateTime result = DateTime.MinValue; if (doc.Contains(propertyName)) { result = doc[propertyName].ToUniversalTime(); } return(result); }
private void FillCursorStatistics(BsonDocument statusOutput, IDictionary <string, object> status) { if (statusOutput.Contains("cursors")) { BsonDocument cursorsOutput = (BsonDocument)statusOutput["cursors"]; IDictionary <string, object> cursors = new Dictionary <string, object>(); status.Add("cursors", cursors); cursors.Add("totalOpen", cursorsOutput["totalOpen"]); } }
public override void UpdateDocument(MongoCollection<BsonDocument> collection, BsonDocument document) { if (document.Contains("oid")) { var organizationId = document.GetValue("oid").AsNullableObjectId; if (!organizationId.HasValue || organizationId.Value == ObjectId.Empty) { document.Remove("oid"); } else { var organizationCollection = Database.GetCollection("organization"); var organization = organizationCollection.FindOneById(organizationId); // The organization with this id could not be found.. Remove the webhook. if (organization == null) { collection.Remove(Query.EQ("_id", document.GetDocumentId())); return; } } } var projectCollection = Database.GetCollection("project"); if (document.Contains("pid")) { var projectId = document.GetValue("pid").AsNullableObjectId; if (!projectId.HasValue || projectId.Value == ObjectId.Empty) { document.Remove("pid"); } else { var project = projectCollection.FindOneById(projectId); // The project with this id could not be found.. Remove the webhook. if (project == null) { collection.Remove(Query.EQ("_id", document.GetDocumentId())); return; } if (!document.Contains("oid")) document.Set("oid", project.GetValue("oid").AsObjectId); } } if (!document.Contains("oid") && !document.Contains("pid")) { collection.Remove(Query.EQ("_id", document.GetDocumentId())); return; } collection.Save(document); }
public static string GetString(BsonDocument doc, string propertyName) { string result = null; if (doc.Contains(propertyName)) { result = doc[propertyName].AsString; } return(result); }
protected override void DropCollection(MongoClient client, string databaseName, string collectionName, BsonDocument test, BsonDocument shared) { base.DropCollection(client, databaseName, collectionName, test, shared); if (shared.Contains("key_vault_data")) { var keyVaultDatabase = client.GetDatabase(__keyVaultCollectionNamespace.DatabaseNamespace.DatabaseName).WithWriteConcern(WriteConcern.WMajority); keyVaultDatabase.DropCollection(__keyVaultCollectionNamespace.CollectionName); } }
/// <summary> /// Get timesheet fragment for asset. Fragment can be returned directly because we always have just one fragment /// and no extra details (overtime etc...). /// </summary> /// <param name="timesheetEntry"></param> /// <returns></returns> private TimesheetEntryFragment GetTimesheetFragmentForAsset(BsonDocument timesheetEntry) { if (!timesheetEntry.Contains("starttimestamp") || !timesheetEntry.Contains("endtimestamp")) { throw new HandlerException("Start or end time missing in asset timesheet entry."); } MongoCollection <BsonDocument> assetsCollection = database.GetCollection("asset"); BsonDocument asset = assetsCollection.FindOne(Query.EQ(DBQuery.Id, timesheetEntry["asset"][0])); MongoCollection <BsonDocument> projectsCollection = database.GetCollection("project"); IMongoQuery query = Query.EQ(DBQuery.Id, timesheetEntry["project"]); BsonDocument project = projectsCollection.FindOne(Query.EQ(DBQuery.Id, (ObjectId)timesheetEntry["project"][0])); if (project == null) { throw new HandlerException("Project not found for asset timesheet entry."); } if (asset == null) { throw new HandlerException("Asset not found for timesheet entry."); } if (!project.Contains("identifier")) { throw new HandlerException("Project is missing an identifier."); } if (!asset.Contains("identifier")) { throw new HandlerException("Asset is missing an identifier."); } if (!asset.Contains("projectcategory")) { throw new HandlerException("Asset is missing category."); } MongoCollection <BsonDocument> projectCategories = database.GetCollection("projectcategory"); BsonDocument projectCategory = projectCategories.FindOne(Query.EQ(DBQuery.Id, asset["projectcategory"][0])); var timesheetEntryWithDetails = new TimesheetEntryWithDetails(); var fragment = new TimesheetEntryFragment(); fragment.Detail = timesheetEntry; fragment.IsRootEntry = true; fragment.ProjectCategoryBase = (string)projectCategory["identifier"]; fragment.ProjectId = (string)project["identifier"]; fragment.Start = ((DateTime)timesheetEntry["starttimestamp"]).ToLocalTime(); fragment.End = ((DateTime)timesheetEntry["endtimestamp"]).ToLocalTime(); fragment.WorkerId = (string)asset["identifier"]; return(fragment); }
public async Task <BsonDocument> FindDuplicate(CollectionEnum collectionEnum, BsonDocument doc) { var col = mongoDB.GetCollection <BsonDocument>(collectionEnum.ToString()); var builder = Builders <BsonDocument> .Filter; FilterDefinition <BsonDocument> filter = null; if (doc.Contains(Const.ID)) { string id = doc.GetValue(Const.ID).AsString; filter = AddFilter(filter, builder.Eq(Const.ID, new ObjectId(id))); } if (collectionEnum == CollectionEnum.entries && doc.Contains(Const.DATE_ELEMENT)) { double date = doc.GetValue(Const.DATE_ELEMENT).AsInt64; filter = AddFilter(filter, builder.Gt(Const.DATE_ELEMENT, date - 1000)); filter = AddFilter(filter, builder.Lt(Const.DATE_ELEMENT, date + 1000)); } if (filter == null) { return(null); } var list = await col.Find(filter) .Limit(1) .ToListAsync(); if (list.Count > 0) { var existingDoc = list[0]; UnpackId(existingDoc); return(existingDoc); } else { return(null); } }
private Type0CommandMessageSection <BsonDocument> CreateType0Section(ConnectionDescription connectionDescription) { var extraElements = new List <BsonElement>(); addIfNotAlreadyAdded("$db", _databaseNamespace.DatabaseName); if (connectionDescription.IsMasterResult.ServerType != ServerType.Standalone && _readPreference != null && _readPreference != ReadPreference.Primary) { var readPreferenceDocument = QueryHelper.CreateReadPreferenceDocument(_readPreference); addIfNotAlreadyAdded("$readPreference", readPreferenceDocument); } if (_session.Id != null) { addIfNotAlreadyAdded("lsid", _session.Id); } if (_session.ClusterTime != null) { addIfNotAlreadyAdded("$clusterTime", _session.ClusterTime); } Action <BsonWriterSettings> writerSettingsConfigurator = s => s.GuidRepresentation = GuidRepresentation.Unspecified; _session.AboutToSendCommand(); if (_session.IsInTransaction) { var transaction = _session.CurrentTransaction; addIfNotAlreadyAdded("txnNumber", transaction.TransactionNumber); if (transaction.State == CoreTransactionState.Starting) { addIfNotAlreadyAdded("startTransaction", true); var readConcern = ReadConcernHelper.GetReadConcernForFirstCommandInTransaction(_session, connectionDescription); if (readConcern != null) { addIfNotAlreadyAdded("readConcern", readConcern); } } addIfNotAlreadyAdded("autocommit", false); } var elementAppendingSerializer = new ElementAppendingSerializer <BsonDocument>(BsonDocumentSerializer.Instance, extraElements, writerSettingsConfigurator); return(new Type0CommandMessageSection <BsonDocument>(_command, elementAppendingSerializer)); void addIfNotAlreadyAdded(string key, BsonValue value) { if (!_command.Contains(key)) { extraElements.Add(new BsonElement(key, value)); } } }
private static string get(string name, BsonDocument b) { string item = ""; if (b.Contains(name)) { item = b.GetValue(name).AsString.Trim(); } return(item); }
// public methods public override void Arrange(BsonDocument document) { JsonDrivenHelper.EnsureFieldEquals(document, "object", "collection"); if (document.Contains("collectionOptions")) { ParseCollectionOptions(document["collectionOptions"].AsBsonDocument); } base.Arrange(document); }
/// <summary> /// 序列化Bson為Redis格式 /// </summary> /// <param name="type"></param> /// <param name="entity"></param> /// <returns></returns> public static List <HashEntry> Serialize(Type type, BsonDocument entity) { List <HashEntry> updatedList = new List <HashEntry>(); string[] propertyNames = GetCachePropertyNames(type); for (int j = 0; j < propertyNames.Length; j++) { string attName = propertyNames[j]; PropertyInfo property = GetCachePropertyInfo(type, attName); // 必須允許更新Null的值 if (!entity.Contains(attName)) { continue; } // 非基本型別轉Json處理 if (!property.PropertyType.IsValueType && property.PropertyType != typeof(string)) { updatedList.Add(new HashEntry(attName, entity[attName].ToJson())); } else { HashEntry entry = new HashEntry(attName, RedisValue.Null); if (property.PropertyType == typeof(long)) { entry = new HashEntry(attName, entity[attName].AsInt64); } else if (property.PropertyType == typeof(int)) { entry = new HashEntry(attName, entity[attName].AsInt32); } else if (property.PropertyType == typeof(string)) { entry = new HashEntry(attName, entity[attName].AsString); } else if (property.PropertyType == typeof(bool)) { entry = new HashEntry(attName, entity[attName].AsBoolean); } else if (property.PropertyType == typeof(float)) { entry = new HashEntry(attName, (float)entity[attName].AsDouble); } else if (property.PropertyType == typeof(double)) { entry = new HashEntry(attName, entity[attName].AsDouble); } updatedList.Add(entry); } } return(updatedList); }
/// <summary> /// 检查请求是否执行成功 /// </summary> /// <param name="response"></param> /// <returns></returns> public static bool CheckResponseOk(BsonDocument response) { if (response.Contains("errcode") && response["errcode"].ToInt64() == 0) { return(true); } else { return(false); } }
/// <summary> /// 获取主键字段名 /// </summary> /// <param name="?"></param> /// <returns></returns> public static string TableName(this BsonDocument bsonDoc) { var tbName = string.Empty; if (bsonDoc.Contains("underTable")) { tbName = bsonDoc.GetValue("underTable").ToString(); //当前记录所属表 } return(tbName); }
private static string GetTestName(string description, BsonDocument definition) { var name = description; if (definition.Contains("description")) { name += " - " + (string)definition["description"]; } return(name); }
private string GetCreatedById(BsonDocument document) { if (document == null || !document.Contains("createBy")) { return(string.Empty); } var createdBy = document["createBy"].AsBsonDocument; return(GetStringValue(createdBy, "id")); }
protected object DeserializeState(BsonDocument doc, out string version, out string id) { string t = doc["_t"].AsString; if (string.IsNullOrEmpty(t)) { throw new Exception("No type discriminator in document"); } Type tt = TypeNameDiscriminator.GetActualType(t); if (tt == null) { throw new Exception("Type not found: " + t); } var ret = BsonSerializer.Deserialize(doc, tt); version = doc.Contains("version") ? doc["version"].AsString : null; id = doc.Contains("_id") ? doc["_id"].AsString : null; return(ret); }
private string GetValue(BsonDocument document, string key) { string value = string.Empty; if (document.Contains(key)) { value = document[key].ToString(); } return(value); }
protected virtual BsonValue GetId(BsonDocument document) { if (document.Contains("_id")) { return(document["_id"]); } else { return(null); } }
protected DateTime getLastRun(BsonDocument dirDoc) { if (dirDoc.Contains("lastRun")) { return(dirDoc.GetValue("lastRun").ToLocalTime()); } else { return(DateTime.Now.AddYears(-100)); }; }
private void FillConnectionStatistics(BsonDocument statusOutput, IDictionary <string, object> status) { if (statusOutput.Contains("connections")) { BsonDocument connectionsOutput = (BsonDocument)statusOutput["connections"]; IDictionary <string, object> connections = new Dictionary <string, object>(); status.Add("connections", connections); connections.Add("current", connectionsOutput["current"]); connections.Add("available", connectionsOutput["available"]); } }
/// <summary> /// 通用设置接口 /// </summary> /// <param name="bsonDoc"></param> /// <param name="fieldName"></param> /// <param name="obj"></param> /// <returns></returns> public static void SetValue(BsonDocument bsonDoc, string fieldName, string obj) { if (bsonDoc.Contains(fieldName)) { bsonDoc[fieldName] = obj; } else { bsonDoc.Add(fieldName, obj); } }
private List <string> ParseMembers(BsonDocument document) { if (document == null || !document.Contains("teamMemberIds")) { return(new List <string>()); } var teamMemberIds = document["teamMemberIds"].AsBsonArray; return(teamMemberIds.Select(i => GetStringValue(i, "userId")).ToList()); }
/// <summary> /// 向对象新增key,如果key已经存在,则修改原先key对应的值 /// </summary> /// <param name="bsonDoc"></param> /// <param name="key">key值</param> /// <param name="val">要新增的对象</param> public static void TryAdd(this BsonDocument bsonDoc, string key, string val) { if (bsonDoc.Contains(key)) { bsonDoc[key] = val; } else { bsonDoc.Add(key, val); } }
/***************************************************/ /**** Public Methods ****/ /***************************************************/ public static string Version(this BsonDocument document) { if (document != null && document.Contains("_bhomVersion")) { return(document["_bhomVersion"].ToString()); } else { return(""); } }
private static BsonDocument GetTimesheetEntryDetailPayType(BsonDocument timesheetEntryDetail, MongoDatabase database) { if (!timesheetEntryDetail.Contains("timesheetentrydetailpaytype")) { throw new HandlerException("Timesheet entry detail pay type missing in timesheet entry detail."); } MongoCollection <BsonDocument> payTypesCollection = database.GetCollection("timesheetentrydetailpaytype"); return(payTypesCollection.FindOne(Query.EQ(DBQuery.Id, timesheetEntryDetail["timesheetentrydetailpaytype"][0]))); }
/*******************************************/ public static object FromBson(BsonDocument bson) { RegisterTypes(); // Patch for handling the case where a string is a top object - will need proper review in next quarter if (bson.Contains("_t") && bson["_t"] == "System.String" && bson.Contains("_v")) { return(bson["_v"].AsString); } bson.Remove("_id"); object obj = BsonSerializer.Deserialize(bson, typeof(object)); if (obj is ExpandoObject) { Dictionary <string, object> dic = new Dictionary <string, object>(obj as ExpandoObject); CustomObject co = new CustomObject(); if (dic.ContainsKey("Name")) { co.Name = dic["Name"] as string; dic.Remove("Name"); } if (dic.ContainsKey("Tags")) { co.Tags = new HashSet <string>(((List <object>)dic["Tags"]).Cast <string>()); dic.Remove("Tags"); } if (dic.ContainsKey("BHoM_Guid")) { co.BHoM_Guid = (Guid)dic["BHoM_Guid"]; dic.Remove("BHoM_Guid"); } co.CustomData = dic; return(co); } else { return(obj); } }
protected virtual void AssertOutcome(BsonDocument outcome, IMongoDatabase database, IMongoCollection <BsonDocument> collection) { if (outcome != null && outcome.Contains("collection")) { var collectionToVerify = collection; if (outcome["collection"].AsBsonDocument.Contains("name")) { collectionToVerify = database.GetCollection <BsonDocument>(outcome["collection"]["name"].ToString()); } VerifyCollection(collectionToVerify, (BsonArray)outcome["collection"]["data"]); } }
private void AssertEvents(EventCapturer actualEvents, BsonDocument test, Dictionary <string, BsonValue> sessionIdMap) { if (test.Contains("expectations")) { foreach (var expectedEvent in test["expectations"].AsBsonArray.Cast <BsonDocument>()) { RecursiveFieldSetter.SetAll(expectedEvent, "lsid", value => sessionIdMap[value.AsString]); var actualEvent = actualEvents.Next(); AssertEvent(actualEvent, expectedEvent); } } }