/// <summary>
/// 获得数据库角色
/// </summary>
/// <param name="DatabaseName"></param>
/// <returns></returns>
public BsonArray GetRolesByDBName(String DatabaseName)
{
BsonArray roles = new BsonArray();
//当前DB的System.user的角色
if (UserList.ContainsKey(DatabaseName)) {
roles = UserList[DatabaseName].roles;
}
///Admin的OtherDBRoles和当前数据库角色合并
BsonArray adminRoles = GetOtherDBRoles(DatabaseName);
foreach (String item in adminRoles)
{
if (!roles.Contains(item)) {
roles.Add(item);
}
}
///ADMIN的ANY系角色的追加
if (UserList.ContainsKey(MongoDBHelper.DATABASE_NAME_ADMIN)) {
if (UserList[MongoDBHelper.DATABASE_NAME_ADMIN].roles.Contains(MongoDBHelper.UserRole_dbAdminAnyDatabase)){
roles.Add(MongoDBHelper.UserRole_dbAdminAnyDatabase);
}
if (UserList[MongoDBHelper.DATABASE_NAME_ADMIN].roles.Contains(MongoDBHelper.UserRole_readAnyDatabase))
{
roles.Add(MongoDBHelper.UserRole_readAnyDatabase);
}
if (UserList[MongoDBHelper.DATABASE_NAME_ADMIN].roles.Contains(MongoDBHelper.UserRole_readWriteAnyDatabase))
{
roles.Add(MongoDBHelper.UserRole_readWriteAnyDatabase);
}
if (UserList[MongoDBHelper.DATABASE_NAME_ADMIN].roles.Contains(MongoDBHelper.UserRole_userAdminAnyDatabase))
{
roles.Add(MongoDBHelper.UserRole_userAdminAnyDatabase);
}
}
return roles;
}
public static void AddLogToCollection(string jsonDocument,string collectionName)
{
try
{
var document = BsonDocument.Parse(jsonDocument);
document = CorrectDateField(document);
var keyValue = document.First().Value.ToString();
var result = new BsonDocument();
result.Add("_id", keyValue);
var mongoRepo = new MongoDBRepository<MongoDBContext>();
var fResult = mongoRepo.FinObjectByKey(collectionName, keyValue).ToList();
if (fResult != null && fResult.Count == 1)
{
var value = fResult.First().Last().Value as BsonArray;
if (value != null)
{
var doc = fResult.First().Last().Value as BsonArray;
doc.Add(document.Last().Value);
CopyMidelElmentInResult(document, result);
result.Add(document.Last().Name, doc);
mongoRepo.ReplaceOne(keyValue, collectionName, result);
}
else
{
var doc = fResult.First().Last().Value as BsonDocument;
var list = new BsonArray();
list.Add(doc);
list.Add(document.Last().Value);
CopyMidelElmentInResult(document, result);
result.Add(doc.Last().Name, list);
mongoRepo.ReplaceOne(keyValue, collectionName, result);
}
}
else
{
CopyMidelElmentInResult(document, result);
var list = new BsonArray();
list.Add(document.Last().Value);
result.Add(document.Last().Name, list);
mongoRepo.AddOne(collectionName, result);
}
}
catch(Exception ex)
{
APILogger.Write(ex.Message, LogLevel.Error);
}
}
public string get_depth_all()
{
string sql = "select max(id) from depth_log where website='btcchina' and type='sell' ";
string max_id = SQLServerHelper.get_table(sql).Rows[0][0].ToString();
sql = "select * from depth_log where id={0}";
sql = string.Format(sql, max_id);
string result_sell = SQLServerHelper.get_table(sql).Rows[0]["text"].ToString();
sql = "select max(id) from depth_log where website='btcchina' and type='buy' ";
max_id = SQLServerHelper.get_table(sql).Rows[0][0].ToString();
sql = "select * from depth_log where id={0}";
sql = string.Format(sql, max_id);
string result_buy = SQLServerHelper.get_table(sql).Rows[0]["text"].ToString();
BsonArray array_sell = MongoHelper.get_array_from_str(result_sell);
BsonArray array_buy = MongoHelper.get_array_from_str(result_buy);
BsonArray list = new BsonArray();
BsonDocument doc_buy = new BsonDocument();
doc_buy.Add("name", "SELL");
BsonArray list_buy = new BsonArray();
for (int i = array_buy.Count-1; i >=0; i--)
{
BsonDocument doc_item = new BsonDocument();
doc_item.Add("x", array_buy[i][0]);
doc_item.Add("y", array_buy[i][1]);
list_buy.Add(doc_item);
}
doc_buy.Add("data", list_buy);
BsonDocument doc_sell = new BsonDocument();
doc_sell.Add("name", "SELL");
BsonArray list_sell = new BsonArray();
for (int i =array_sell.Count-1; i>=0; i--)
{
BsonDocument doc_item = new BsonDocument();
doc_item.Add("x", array_sell[i][0]);
doc_item.Add("y", array_sell[i][1]);
list_sell.Add(doc_item);
}
doc_sell.Add("data", list_sell);
list.Add(doc_buy);
list.Add(doc_sell);
return list.ToString();
}
public static void insert_trade(string result, string pair)
{
StringBuilder sb = new StringBuilder();
BsonArray list = MongoHelper.get_array_from_str(result);
BsonArray sell=new BsonArray();
BsonArray buy=new BsonArray();
for (int i = 0; i < list.Count; i++)
{
BsonDocument doc_item = new BsonDocument();
doc_item["id"] = list[i]["tid"].ToString();
doc_item["time"] = list[i]["date"].ToString();
doc_item["price"] = list[i]["price"].ToString();
doc_item["qty"] = list[i]["amount"].ToString();
if (list[i]["type"].ToString() == "sell")
{
sell.Add(doc_item);
}
if (list[i]["type"].ToString() == "buy")
{
buy.Add(doc_item);
}
}
BtcHelper.insert_trade_log("btcchina", pair, "sell", "btc", sell.ToString());
BtcHelper.insert_trade_log("btcchina", pair, "buy", "btc", buy.ToString());
}
public void TestAddNull()
{
var array = new BsonArray();
var value = (BsonValue)null;
array.Add(value);
Assert.AreEqual(0, array.Count);
}
public static void AddField(this BsonDocument doc, string name, object value)
{
if (value == null) return;
var unifiedName = name.ToLower();
switch (unifiedName)
{
case "exception":
doc[name] = BuildExceptionBsonDocument((Exception)value); break;
case "properties":
var properties = (IDictionary<object, object>)value;
if (properties.Count > 0)
doc[name] = BuildPropertiesBsonDocument(properties);
break;
case "parameters":
var parameters = (object[])value;
BsonArray array = new BsonArray();
foreach (var param in parameters)
{
array.Add(SafeCreateBsonValue(param));
}
doc[name] = array;
break;
default:
doc[name] = SafeCreateBsonValue(value);
break;
}
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(BsonArray));
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Array:
bsonReader.ReadStartArray();
var array = new BsonArray();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var value = (BsonValue)BsonValueSerializer.Instance.Deserialize(bsonReader, typeof(BsonValue), null);
array.Add(value);
}
bsonReader.ReadEndArray();
return array;
default:
var message = string.Format("Cannot deserialize BsonArray from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
/// <summary>
/// </summary>
/// <param name="SubNode"></param>
/// <returns></returns>
public static BsonDocument ConvertTreeNodeTozTreeBsonDoc(TreeNode SubNode)
{
var SingleNode = new BsonDocument();
SingleNode.Add("name", SubNode.Text + GetTagText(SubNode));
if (SubNode.Nodes.Count == 0)
{
SingleNode.Add("icon", "MainTreeImage" + String.Format("{0:00}", SubNode.ImageIndex) + ".png");
}
else
{
var ChildrenList = new BsonArray();
foreach (TreeNode item in SubNode.Nodes)
{
ChildrenList.Add(ConvertTreeNodeTozTreeBsonDoc(item));
}
SingleNode.Add("children", ChildrenList);
SingleNode.Add("icon", "MainTreeImage" + String.Format("{0:00}", SubNode.ImageIndex) + ".png");
}
if (SubNode.IsExpanded)
{
SingleNode.Add("open", "true");
}
if (SubNode.Tag != null)
{
SingleNode.Add("click",
"ShowData('" + SystemManager.GetTagType(SubNode.Tag.ToString()) + "','" +
SystemManager.GetTagData(SubNode.Tag.ToString()) + "')");
}
return SingleNode;
}
public override void Build(MongoDB.Bson.BsonDocument bsonPanelSetOrder, int panelSetId)
{
base.Build(bsonPanelSetOrder, panelSetId);
string reportNo = bsonPanelSetOrder.GetValue("ReportNo").ToString();
MongoCollection surgicalSpecimenTable = this.m_SQLTransferDatabase.GetCollection<BsonDocument>("tblSurgicalSpecimen");
MongoCursor mongoCursor = surgicalSpecimenTable.FindAs<BsonDocument>(Query.EQ("ReportNo", reportNo));
BsonArray bsonArray = new BsonArray();
foreach (BsonDocument bsonSurgicalSpecimen in mongoCursor)
{
string surgicalSpecimenId = bsonSurgicalSpecimen.GetValue("SurgicalSpecimenId").AsString;
this.BuildIC(bsonSurgicalSpecimen, surgicalSpecimenId);
this.BuildStainResult(bsonSurgicalSpecimen, surgicalSpecimenId);
this.BuildICD9BillingCode(bsonSurgicalSpecimen, surgicalSpecimenId);
bsonArray.Add(bsonSurgicalSpecimen);
}
bsonPanelSetOrder.Add("SurgicalSpecimenCollection", bsonArray);
MongoCollection surgicalAuditTable = this.m_SQLTransferDatabase.GetCollection<BsonDocument>("tblSurgicalAudit");
MongoCursor surgicalAuditCursor = surgicalAuditTable.FindAs<BsonDocument>(Query.EQ("ReportNo", reportNo));
BsonArray surgicalAuditArray = new BsonArray();
foreach (BsonDocument bsonSurgicalAudit in surgicalAuditCursor)
{
string surgicalAuditId = bsonSurgicalAudit.GetValue("SurgicalAuditId").AsString;
this.BuildSurgicalSpecimenAudit(bsonSurgicalAudit, surgicalAuditId);
surgicalAuditArray.Add(bsonSurgicalAudit);
}
bsonPanelSetOrder.Add("SurgicalAuditCollection", surgicalAuditArray);
}
public BsonDocument Serialize(Scope scope)
{
var doc = new BsonDocument();
doc["_id"] = scope.Name;
doc["_version"] = 1;
doc.SetIfNotNull("displayName", scope.DisplayName);
var claims = new BsonArray();
foreach (ScopeClaim scopeClaim in scope.Claims)
{
var claim = new BsonDocument();
claim["name"] = scopeClaim.Name;
claim["alwaysIncludeInIdToken"] = scopeClaim.AlwaysIncludeInIdToken;
claim.SetIfNotNull("description", scopeClaim.Description);
claims.Add(claim);
}
doc["claims"] = claims;
doc.SetIfNotNull("claimsRule", scope.ClaimsRule);
doc.SetIfNotNull("description", scope.Description);
doc["emphasize"] = scope.Emphasize;
doc["enabled"] = scope.Enabled;
doc["includeAllClaimsForUser"] = scope.IncludeAllClaimsForUser;
doc["required"] = scope.Required;
doc["showInDiscoveryDocument"] = scope.ShowInDiscoveryDocument;
doc["type"] = scope.Type.ToString();
return doc;
}
public void Post(UserModel model)
{
var mongoDbClient = new MongoClient("mongodb://127.0.0.1:27017");
var mongoDbServer = mongoDbClient.GetDatabase("SocialNetworks");
BsonArray arr = new BsonArray();
dynamic jobj = JsonConvert.DeserializeObject<dynamic>(model.Movies.ToString());
foreach (var item in jobj)
{
foreach(var subitem in item)
{
arr.Add(subitem.Title.ToString());
}
}
var document = new BsonDocument
{
{ "Facebook_ID", model.Facebook_ID },
{ "Ime", model.Ime },
{ "Prezime", model.Prezime },
{ "Email", model.Email },
{ "DatumRodjenja", model.DatumRodjenja },
{ "Hometown", model.Hometown},
{ "ProfilePictureLink", model.ProfilePictureLink },
{ "Movies", arr },
};
var collection = mongoDbServer.GetCollection<BsonDocument>("UserInfo");
collection.InsertOneAsync(document);
}
public void TestAdd()
{
var array = new BsonArray();
var value = BsonValue.Create(1);
array.Add(value);
Assert.AreEqual(1, array.Count);
Assert.AreEqual(value, array[0]);
}
/// <summary>
/// </summary>
/// <param name="tree"></param>
/// <returns></returns>
public static String ConvertTreeViewTozTreeJson(TreeView tree)
{
var array = new BsonArray();
foreach (TreeNode item in tree.Nodes)
{
array.Add(ConvertTreeNodeTozTreeBsonDoc(item));
}
return array.ToJson(MongoUtility.Basic.Utility.JsonWriterSettings);
}
/// <summary>
///
/// </summary>
/// <param name="tree"></param>
/// <returns></returns>
public static String ConvertTreeViewTozTreeJson(TreeView tree)
{
BsonArray array = new BsonArray();
foreach (TreeNode item in tree.Nodes)
{
array.Add(ConvertTreeNodeTozTreeBsonDoc(item));
}
return array.ToJson(SystemManager.JsonWriterSettings);
}
/// <summary>
/// 获取角色下所有用户(当前用户角色可见)
/// </summary>
/// <param name="Options">查询参数</param>
/// <param name="ReceiveMessage">回调消息</param>
public void GetAllUserByRole(BsonDocument Options, BsonDocument ReceiveMessage)
{
ObjectId RoleId = new ObjectId(Options.GetValue("UserRoleId").ToString());
BsonArray RoleList = urs.GetAllChildren(RoleId);
//RoleList.Add(urs.FindOne(RoleId).ToBsonDocument());//无法编辑自己的角色权限
BsonArray RoleIds = new BsonArray();
RoleIds.Add(RoleId);
foreach (BsonValue ur in RoleList)
{
RoleIds.Add(ur["_id"]);
}
BsonArray UserList = us.GetAllUsersByRole(RoleIds);
BsonDocument json = new BsonDocument();
json.Add("RoleList", RoleList);
json.Add("UserList", UserList);
ReceiveMessage.Add("StateCode", 0);//登录成功
ReceiveMessage.Add("ReData", json.ToJson(jsonSettings));
CallBack();
}
/// <summary>
/// 把String类型的ObjectId转换成ObjectId类型
/// </summary>
/// <param name="Array">未转换数组</param>
/// <returns>返回数组</returns>
public static BsonArray StrinIdToObjectId(BsonArray Array)
{
BsonArray newArray = new BsonArray();
foreach (BsonValue Id in Array)
{
newArray.Add(new ObjectId(Id.AsString));
}
return newArray;
}
/// <summary>
/// 获得数据库角色
/// </summary>
/// <param name="databaseName"></param>
/// <returns></returns>
public BsonArray GetRolesByDbName(string databaseName)
{
var roles = new BsonArray();
//当前DB的System.user的角色
if (UserList.ContainsKey(databaseName))
{
roles = UserList[databaseName].Roles;
}
//Admin的OtherDBRoles和当前数据库角色合并
var adminRoles = GetOtherDbRoles(databaseName);
foreach (string item in adminRoles)
{
if (!roles.Contains(item))
{
roles.Add(item);
}
}
//ADMIN的ANY系角色的追加
if (UserList.ContainsKey(ConstMgr.DatabaseNameAdmin))
{
if (UserList[ConstMgr.DatabaseNameAdmin].Roles.Contains(Role.UserRoleDbAdminAnyDatabase))
{
roles.Add(Role.UserRoleDbAdminAnyDatabase);
}
if (UserList[ConstMgr.DatabaseNameAdmin].Roles.Contains(Role.UserRoleReadAnyDatabase))
{
roles.Add(Role.UserRoleReadAnyDatabase);
}
if (
UserList[ConstMgr.DatabaseNameAdmin].Roles.Contains(
Role.UserRoleReadWriteAnyDatabase))
{
roles.Add(Role.UserRoleReadWriteAnyDatabase);
}
if (
UserList[ConstMgr.DatabaseNameAdmin].Roles.Contains(
Role.UserRoleUserAdminAnyDatabase))
{
roles.Add(Role.UserRoleUserAdminAnyDatabase);
}
}
return roles;
}
/// <summary>
/// 查询所有权限
/// </summary>
/// <param name="Query">查询条件</param>
/// <returns>返回权限集合</returns>
public BsonArray GetAll(BsonArray Query)
{
BsonArray PowerList = new BsonArray();
List<BsonDocument> UserPowersDoc = dh.GetAllData("userpowers", new BsonDocument { { "_id", new BsonDocument { { "$in", Query } } } });
foreach (BsonDocument UserPower in UserPowersDoc)
{
PowerList.Add(new UserPower(UserPower).ToBsonDocument());
}
return PowerList;
}
public static BsonDocument dropScore(BsonDocument document)
{
var homeworks = document["scores"].AsBsonArray.Where(value => value.ToBsonDocument()["type"] == "homework").ToList();
var others = document["scores"].AsBsonArray.Where(value => value.ToBsonDocument()["type"] == "exam" || value.ToBsonDocument()["type"] == "quiz").ToList();
var array = new BsonArray();
others.Add((homeworks[0].ToBsonDocument()["score"].ToDouble() > homeworks[1].ToBsonDocument()["score"].ToDouble()) ? homeworks[0] : homeworks[1]);
others.ForEach(data => array.Add(data.ToBsonDocument()));
return new BsonDocument("_id", document["_id"]).Add("name", document["name"]).Add("scores", array);
}
public void TestCircularBsonArray()
{
// note: setting a breakpoint in this method will crash the debugger if the locals window is open
// because it tries to display the value of array (presumably it's getting an internal stack overflow)
var array = new BsonArray();
array.Add(array);
var c1 = new C { X = 1, BsonArray = array };
Assert.Throws<BsonSerializationException>(() => { var json = c1.ToBson(); });
Assert.Throws<BsonSerializationException>(() => { var json = c1.ToBsonDocument(); });
Assert.Throws<BsonSerializationException>(() => { var json = c1.ToJson(); });
}
/// <summary>
/// 获得数组
/// </summary>
/// <returns></returns>
public BsonArray GetBsonArray()
{
BsonArray ValueList = new BsonArray();
foreach (ctlBsonValue item in this.Controls)
{
if (item.getValue() != null)
{
ValueList.Add(item.getValue());
}
}
return ValueList;
}
public async void SaveActiveQuests(string npcId) {
BsonDocument quest = new BsonDocument();
BsonArray activeQuests = new BsonArray();
activeQuests.Add(quest);
BsonDocument result = new BsonDocument();
result.Add("_id", npcId);
result.Add("ActiveQuests", activeQuests);
await MongoUtils.MongoData.SaveAsync<BsonDocument>(MongoUtils.MongoData.GetCollection<BsonDocument>("NPCS", "Quests"), q => q["_id"] == npcId, result);
}
/// <summary>
/// 获得数组
/// </summary>
/// <returns></returns>
public BsonArray GetBsonArray()
{
var valueList = new BsonArray();
foreach (CtlBsonValue item in Controls)
{
if (item.GetValue() != null)
{
valueList.Add(item.GetValue());
}
}
return valueList;
}
public void Serialize(IEnumerable<Claim> claims, BsonDocument doc)
{
doc["_version"] = 1;
var array = new BsonArray();
foreach (Claim claim in claims)
{
var c = new BsonDocument();
c["type"] = claim.Type;
c["value"] = claim.Value;
array.Add(c);
}
doc["claims"] = array;
}
private void BuildAliquotOrder(BsonDocument bsonParent)
{
MongoCollection aliquotOrderTable = this.m_SQLTransferDatabase.GetCollection<BsonDocument>("tblAliquotOrder");
MongoCursor mongoCursor = aliquotOrderTable.FindAs<BsonDocument>(Query.EQ("SpecimenOrderId", bsonParent.GetValue("SpecimenOrderId")));
BsonArray array = new BsonArray();
foreach (BsonDocument bsonChild in mongoCursor)
{
array.Add(bsonChild);
}
bsonParent.Add("AliquotOrderCollection", array);
}
private void BuildICD9BillingCodeCollection(BsonDocument bsonParent)
{
MongoCollection mongoCollection = this.m_SQLTransferDatabase.GetCollection<BsonDocument>("tblICD9BillingCodeCollection");
MongoCursor mongoCursor = mongoCollection.FindAs<BsonDocument>(Query.EQ("MasterAccessionNo", bsonParent.GetValue("MasterAccessionNo")));
BsonArray array = new BsonArray();
foreach (BsonDocument bsonChild in mongoCursor)
{
array.Add(bsonChild);
}
bsonParent.Add("ICD9BillingCodeCollection", array);
}
private void BuildICD9BillingCode(BsonDocument bsonSurgicalSpecimen, string surgicalSpecimenId)
{
MongoCollection icd9BillingCodeTable = this.m_SQLTransferDatabase.GetCollection<BsonDocument>("tblICD9BillingCode");
MongoCursor mongoCursor = icd9BillingCodeTable.FindAs<BsonDocument>(Query.EQ("SurgicalSpecimenId", surgicalSpecimenId));
BsonArray bsonArray = new BsonArray();
foreach (BsonDocument bsonICD9BillingCode in mongoCursor)
{
bsonArray.Add(bsonICD9BillingCode);
}
bsonSurgicalSpecimen.Add("ICD9BillingCodeCollection", bsonArray);
}
/// <summary>
/// 获取角色下所有角色
/// </summary>
/// <param name="RoleId">角色Id</param>
/// <returns>返回所有角色集合</returns>
public BsonArray GetAllChildren(ObjectId RoleId)
{
BsonArray RoleList = new BsonArray();
List<BsonDocument> RoleDoc = dh.GetAllData("userroles", new BsonDocument { { "PUserRole", RoleId } });
foreach (BsonDocument Role in RoleDoc)
{
UserRole ur = new UserRole(Role);
ur.UserRolePowers = ups.GetAll(ur.UserRolePowers);
RoleList.AddRange(GetAllChildren(ur.Id));
RoleList.Add(ur.ToBsonDocument());
}
return RoleList;
}
private void BuildClientLocation(BsonDocument bsonParent)
{
MongoCollection clientLocationTable = this.m_SQLTransferDatabase.GetCollection<BsonDocument>("tblClientLocation");
MongoCursor mongoCursor = clientLocationTable.FindAs<BsonDocument>(Query.EQ("ClientId", bsonParent.GetValue("ClientId").AsInt32));
BsonArray array = new BsonArray();
foreach (BsonDocument bsonChild in mongoCursor)
{
array.Add(bsonChild);
}
bsonParent.Add("ClientLocationCollection", array);
}
/// <summary>
/// Método com exemplo de criação e exibição do documento no console.
/// </summary>
static void DocumentBson()
{
var doc = new BsonDocument();
doc.Add("nome", "joao");
doc.Add("idade", 20);
var array = new BsonArray();
array.Add(new BsonDocument("treinamento", "c#"));
array.Add(new BsonDocument("treinamento", "mongo"));
doc.Add("treinamentos", array);
//Console.WriteLine(doc);
//procedimento para capturar elemento.
var arrayCapturado = new BsonElement();
doc.TryGetElement("treinamentos", out arrayCapturado);
Console.WriteLine(arrayCapturado);
Console.ReadKey();
}
public static BsonDocument Serialize(Game game)
{
var document = new BsonDocument();
document.Set("_id", new BsonObjectId(game.Id));
document.Set("active_player", PlayerUtils.ToString(game.Engine.ActivePlayer));
document.Set("game_state", GameStateUtils.ToString(game.Engine.QuantumChessboard.GameState));
document.Set("creation_time", game.Engine.CreationTime);
document.Set("last_modification_time", DateTime.Now);
var bson_harmonics = new BsonArray();
foreach (QuantumHarmonic harmonic in game.Engine.QuantumChessboard.Harmonics)
{
var bson_harmonic = new BsonDocument();
bson_harmonic.Set("harmonic_state", GameStateUtils.ToString(harmonic.Board.GameState));
bson_harmonic.Set("degeneracy", Convert.ToInt64(harmonic.Degeneracy));
var bson_chessboard = new BsonArray();
for (int i = 0; i < 64; i++)
{
Piece?piece = harmonic.Board[i];
if (piece.HasValue)
{
var bson_piece = new BsonDocument();
bson_piece.Set("player", PlayerUtils.ToString(piece.Value.Player));
bson_piece.Set("piece", PieceTypeUtils.ToString(piece.Value.PieceType));
bson_chessboard.Add(bson_piece);
}
else
{
bson_chessboard.Add(BsonNull.Value);
}
}
bson_harmonic.Set("chessboard", bson_chessboard);
bson_harmonics.Add(bson_harmonic);
}
document.Set("harmonics", bson_harmonics);
var last_move_positions = new BsonArray();
foreach (Position pos in game.Engine.LastMovePositions)
{
last_move_positions.Add(pos.ToString());
}
document.Set("last_move_positions", last_move_positions);
return(document);
}
/// <summary>
/// 处理数组（key转小写）
/// </summary>
/// <param name="doc"></param>
/// <param name="projectFields"></param>
/// <returns></returns>
private BsonArray HandleArray(BsonArray docs, string projectFields)
{
BsonArray newDoc = new BsonArray();
foreach (var doc in docs)
{
if (doc.IsBsonArray)
{
newDoc.Add(HandleArray(doc.AsBsonArray, projectFields));
}
else if (doc.IsBsonDocument)
{
newDoc.Add(HandleDoc(doc.AsBsonDocument, projectFields));
}
else
{
newDoc.AddRange(docs);
break;
}
}
return(newDoc);
}
static BsonArray EnumerableAsBsonArray(IEnumerable enumerable)
{
var array = new BsonArray();
if (enumerable != null)
{
foreach (var element in enumerable)
{
array.Add(ValueAsBsonValue(element));
}
}
return(array);
}
private static void AddClause(BsonArray clauses, BsonDocument filter)
{
if (filter.ElementCount == 1 && filter.GetElement(0).Name == "$or")
{
// flatten nested $or
clauses.AddRange((BsonArray)filter[0]);
}
else
{
// we could shortcut the user's query if there are no elements in the filter, but
// I'd rather be literal and let them discover the problem on their own.
clauses.Add(filter);
}
}
private void BuildStainResult(BsonDocument bsonSurgicalSpecimen, string surgicalSpecimenId)
{
MongoCollection stainResultTable = this.m_SQLTransferDatabase.GetCollection <BsonDocument>("tblStainResult");
MongoCursor mongoCursor = stainResultTable.FindAs <BsonDocument>(Query.EQ("SurgicalSpecimenId", surgicalSpecimenId));
BsonArray bsonArray = new BsonArray();
foreach (BsonDocument bsonStainResult in mongoCursor)
{
bsonArray.Add(bsonStainResult);
}
bsonSurgicalSpecimen.Add("StainResultItemCollection", bsonArray);
}
public BsonDocument CriarDocumentoMongo()
{
//Criar um objeto json com BSon
var doc = new BsonDocument {
{ "Titulo", "Guerra dos Tronos" }
};
//O BSon é dinamico e podemos adicionar novos atributos
doc.Add("Autor", "George");
doc.Add("Ano", 1999);
doc.Add("Paginas", 856);
//Criando uma lista de subDocumentos
var assuntoArray = new BsonArray();
assuntoArray.Add("Fantasia");
assuntoArray.Add("Ação");
//Adicionando uma lista de subdocumento a um documento
doc.Add("Assunto", assuntoArray);
return(doc);
}
private void BuildICD9BillingCode(BsonDocument bsonSurgicalSpecimen, string surgicalSpecimenId)
{
MongoCollection icd9BillingCodeTable = this.m_SQLTransferDatabase.GetCollection <BsonDocument>("tblICD9BillingCode");
MongoCursor mongoCursor = icd9BillingCodeTable.FindAs <BsonDocument>(Query.EQ("SurgicalSpecimenId", surgicalSpecimenId));
BsonArray bsonArray = new BsonArray();
foreach (BsonDocument bsonICD9BillingCode in mongoCursor)
{
bsonArray.Add(bsonICD9BillingCode);
}
bsonSurgicalSpecimen.Add("ICD9BillingCodeCollection", bsonArray);
}
private void BuildSurgicalSpecimenAudit(BsonDocument bsonSurgicalAudit, string surgicalAuditId)
{
MongoCollection surgicalSpecimenAuditTable = this.m_SQLTransferDatabase.GetCollection <BsonDocument>("tblSurgicalSpecimenAudit");
MongoCursor mongoCursor = surgicalSpecimenAuditTable.FindAs <BsonDocument>(Query.EQ("SurgicalAuditId", surgicalAuditId));
BsonArray bsonArray = new BsonArray();
foreach (BsonDocument bsonSurgicalSpecimenAudit in mongoCursor)
{
bsonArray.Add(bsonSurgicalSpecimenAudit);
}
bsonSurgicalAudit.Add("SurgicalSpecimenAuditCollection", bsonArray);
}
/// <summary>
/// Combines subqueries with an or operator.
/// </summary>
/// <param name="queries">The subqueries.</param>
/// <returns>The builder (so method calls can be chained).</returns>
public static QueryComplete Or(
params QueryComplete[] queries
)
{
var clauses = new BsonArray();
foreach (var query in queries)
{
clauses.Add(query.ToBsonDocument());
}
var document = new BsonDocument("$or", clauses);
return(new QueryComplete(document));
}
public void Serialize(IEnumerable <Claim> claims, BsonDocument doc)
{
doc["_version"] = 1;
var array = new BsonArray();
foreach (Claim claim in claims)
{
var c = new BsonDocument();
c["type"] = claim.Type;
c["value"] = claim.Value;
array.Add(c);
}
doc["claims"] = array;
}
protected IMongoQuery WrapQuery(IMongoQuery query, BsonDocument options, ReadPreference readPreference, bool forShardRouter)
{
BsonDocument formattedReadPreference = null;
if (forShardRouter && readPreference != null && readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary)
{
BsonArray tagSetsArray = null;
if (readPreference.TagSets != null)
{
tagSetsArray = new BsonArray();
foreach (var tagSet in readPreference.TagSets)
{
var tagSetDocument = new BsonDocument();
foreach (var tag in tagSet)
{
tagSetDocument.Add(tag.Name, tag.Value);
}
tagSetsArray.Add(tagSetDocument);
}
}
if (tagSetsArray != null || readPreference.ReadPreferenceMode != ReadPreferenceMode.SecondaryPreferred)
{
formattedReadPreference = new BsonDocument
{
{ "mode", MongoUtils.ToCamelCase(readPreference.ReadPreferenceMode.ToString()) },
{ "tags", tagSetsArray, tagSetsArray != null } // optional
};
}
}
if (options == null && formattedReadPreference == null)
{
return(query);
}
else
{
var queryDocument = (query == null) ? (BsonValue) new BsonDocument() : BsonDocumentWrapper.Create(query);
var wrappedQuery = new QueryDocument
{
{ "$query", queryDocument },
{ "$readPreference", formattedReadPreference, formattedReadPreference != null }, // only if sending query to a mongos
};
if (options != null)
{
wrappedQuery.Merge(options);
}
return(wrappedQuery);
}
}
public void SaveClient(Client client, TObjectState state)
{
IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
IMongoCollection <BsonDocument> collection = database.GetCollection <BsonDocument>("Client");
EnsureIndexExists <BsonDocument>(collection, "OrganisationID");
FilterDefinition <BsonDocument> query = Builders <BsonDocument> .Filter.Eq("_id", client.ClientID.ToByteArray());
if ((state == TObjectState.Add) || (state == TObjectState.Update))
{
BsonDocument doc = new BsonDocument();
BsonHelper.SetValue(doc, "_id", client.ClientID);
BsonHelper.SetValue(doc, "Name", client.Name);
BsonHelper.SetValue(doc, "OrganisationID", client.OrganisationID);
BsonHelper.SetValue(doc, "Lifetime", client.Lifetime);
BsonHelper.SetValue(doc, "Version", client.Version.ToString());
BsonHelper.SetValue(doc, "BindingMode", (int)client.BindingMode);
BsonHelper.SetValue(doc, "SMSNumber", client.SMSNumber);
BsonHelper.SetValue(doc, "Server", client.Server);
BsonHelper.SetValue(doc, "LastActivityTime", client.LastActivityTime);
if (client.SupportedTypes.Count > 0)
{
BsonArray array = new BsonArray();
foreach (ObjectType supportedType in client.SupportedTypes)
{
BsonDocument supportedTypeDoc = new BsonDocument();
BsonHelper.SetValue(supportedTypeDoc, "_id", supportedType.ObjectTypeID);
BsonHelper.SetValue(supportedTypeDoc, "Path", supportedType.Path);
if (supportedType.Instances.Count > 0)
{
BsonArray instances = new BsonArray();
foreach (int instance in supportedType.Instances)
{
instances.Add(instance);
}
supportedTypeDoc.Add("Instances", instances);
}
array.Add(supportedTypeDoc);
}
doc.Add("SupportedTypes", array);
}
UpdateOptions options = new UpdateOptions();
options.IsUpsert = true;
collection.ReplaceOne(query, doc, options);
}
else if (state == TObjectState.Delete)
{
collection.DeleteOne(query);
}
}
/// <summary>
/// 实体对象转BsonDocument
/// </summary>
/// <param name="entity">实体对象</param>
/// <returns></returns>
protected override BsonDocument EntityToDoc(WaterExpense entity)
{
BsonDocument doc = new BsonDocument
{
{ "accountId", entity.AccountId },
{ "feeType", entity.FeeType },
{ "belongDate", entity.BelongDate },
{ "ticketDate", entity.TicketDate },
{ "totalQuantity", entity.TotalQuantity },
{ "totalAmount", entity.TotalAmount },
{ "createBy", new BsonDocument {
{ "userId", entity.CreateBy.UserId },
{ "name", entity.CreateBy.Name },
{ "time", entity.CreateBy.Time }
} },
{ "updateBy", new BsonDocument {
{ "userId", entity.UpdateBy.UserId },
{ "name", entity.UpdateBy.Name },
{ "time", entity.UpdateBy.Time }
} },
{ "remark", entity.Remark },
{ "status", entity.Status }
};
if (entity.Records != null && entity.Records.Count > 0)
{
BsonArray array = new BsonArray();
foreach (var item in entity.Records)
{
BsonDocument record = new BsonDocument
{
{ "meterNumber", item.MeterNumber },
{ "meterName", item.MeterName },
{ "feeType", item.FeeType },
{ "previous", item.Previous },
{ "current", item.Current },
{ "quantity", item.Quantity },
{ "unitPrice", item.UnitPrice },
{ "amount", item.Amount },
{ "remark", item.Remark }
};
array.Add(record);
}
doc.Add("records", array);
}
return(doc);
}
/// <summary>
/// create file
/// </summary>
/// <param name="filepath"></param>
/// <param name="buffer"></param>
/// <param name="ownerId"></param>
/// <param name="roles"></param>
/// <returns></returns>
public IStorageFile Create(string filepath, byte[] buffer, DateTime?modificationDate, Guid?ownerId = null, List <Guid> roles = null)
{
if (string.IsNullOrWhiteSpace(filepath))
{
throw new ArgumentException("filepath cannot be null or empty");
}
//all filepaths are lowercase and all starts with folder separator
filepath = filepath.ToLowerInvariant();
if (!filepath.StartsWith(FOLDER_SEPARATOR))
{
filepath = FOLDER_SEPARATOR + filepath;
}
if (Find(filepath) != null)
{
throw new ArgumentException(filepath + ": file already exists");
}
BsonDocument metadata = new BsonDocument();
metadata.Add(new BsonElement("owner_id", ownerId));
BsonArray rolesArr = new BsonArray();
if (roles != null && roles.Count > 0)
{
foreach (var roleId in roles)
{
rolesArr.Add(BsonValue.Create(roleId));
}
}
metadata.Add(new BsonElement("available_to_roles", rolesArr));
if (modificationDate == null)
{
modificationDate = DateTime.UtcNow;
}
using (var stream = gfs.OpenWrite(filepath, new MongoGridFSCreateOptions {
UploadDate = modificationDate.Value, Metadata = metadata
}))
{
if (buffer != null && buffer.Length > 0)
{
stream.Write(buffer, 0, buffer.Length);
}
}
return(Find(filepath));
}
public static BsonArray get_candle(string website, DateTime start_time, DateTime end_time, int seconds)
{
BsonArray list = new BsonArray();
UInt64 u_start_time = UnixTime.get_unix_time_from_local_long(start_time);
UInt64 u_end_time = UnixTime.get_unix_time_from_local_long(end_time);
while (u_start_time < u_end_time)
{
DateTime dt = UnixTime.get_local_time_long(u_start_time);
BsonDocument doc = get_region("", dt, seconds);
list.Add(doc);
u_start_time = UnixTime.get_unix_time_from_local_long(dt.AddSeconds(seconds));
}
return(list);
}
public void TestCircularBsonArray()
{
// note: setting a breakpoint in this method will crash the debugger if the locals window is open
// because it tries to display the value of array (presumably it's getting an internal stack overflow)
var array = new BsonArray();
array.Add(array);
var c1 = new C {
X = 1, BsonArray = array
};
Assert.Throws <BsonSerializationException>(() => c1.ToBson());
Assert.Throws <BsonSerializationException>(() => c1.ToBsonDocument());
Assert.Throws <BsonSerializationException>(() => c1.ToJson());
}
public void InserirItem()
{
string palavra = "yo";
BsonArray bLista = new BsonArray();
bLista.Add(new BsonDocument("campo", "valor"));
bLista.Add(new BsonDocument("campo2", "valor2"));
var document = new BsonDocument
{
{ "name", "MongoDB" },
{ "type", bLista },
{ "campo", palavra },
{ "tipo", 45.6 },
{ "count", 1 },
{ "info", new BsonDocument
{
{ "x", 203 },
{ "y", 102 }
} }
};
collection.InsertOne(document);
}// fim inserir
public BsonArray get_array_from_str(string str)
{
str = str.Replace("\r\n", "");
BsonArray array = new BsonArray();
if (!string.IsNullOrEmpty(str))
{
string[] list = str.Split('$');
foreach (string item in list)
{
array.Add(item);
}
}
return(array);
}
public virtual List <T> GetById(List <ObjectId> Id)
{
var collection = GetCollection <T>();
var IdArray = new BsonArray();
foreach (ObjectId singleId in Id)
{
IdArray.Add(BsonValue.Create(singleId));
}
var filter = Builders <T> .Filter.In <BsonValue>("_id", IdArray);
var entity = collection.Find <T>(filter);
return(entity.ToList());
}
private void AddComposite(Dictionary <string, double> stats, string itemClass, BsonArray Composite)
{
Console.WriteLine("Add Composite");
BsonDocument compositeStat = new BsonDocument();
SetStats(compositeStat, stats);
compositeStat.Add("ItemClass", itemClass);
string icon = SQLiteConnect.GetIcon(itemClass);
compositeStat.Add("Icon", icon);
string statStr = GetStatString(stats);
compositeStat.Add("StatStr", statStr);
Composite.Add(compositeStat);
}
private BsonArray SerializeTransitionEvents(List <TransitionEvent> events)
{
BsonArray array = new BsonArray();
foreach (var e in events)
{
array.Add(new BsonDocument()
{
{ "TypeId", e.TypeId },
{ "Data", _dataSerializer.Serialize(e.Data) }
});
}
return(array);
}
/// <summary>
/// Hàm dùng cập nhật 1 số trường trong database theo điều kiện filter
/// </summary>
/// <param name="bsArrFilter"> BsonArray Mảng điều kiện filter</param>
/// <param name="bsUpdate"> BsonDocument các trường cần cập nhật</param>
/// <param name="clientSession"></param>
/// <returns></returns>
public async Task <UpdateResult> UpdateCustomizeFieldAsync(BsonArray bsArrFilter, BsonDocument bsUpdate, IClientSessionHandle clientSession = null)
{
if (bsArrFilter == null || bsUpdate == null)
{
return(null);
}
FilterDefinition <T> filter = new BsonDocument("$and", bsArrFilter.Add(new BsonDocument("IsActive", true)));
UpdateDefinition <T> update = new BsonDocument("$set", bsUpdate.Add("UpdatedOn", DateTime.Now));
if (clientSession == null)
{
return(await _collection.UpdateManyAsync(filter, update).ConfigureAwait(false));
}
return(await _collection.UpdateManyAsync(clientSession, filter, update).ConfigureAwait(false));
}
private BsonValue BuildCollection(Node node)
{
if (!_jsonSingleChildAsCollection && node.Children.Count == 1)
{
return(BuildDocument(node.Children[0]));
}
BsonArray list = new BsonArray();
foreach (var row in node.Children)
{
BsonDocument doc = BuildDocument(row);
list.Add(doc);
}
return(list);
}
private void SetDocumentAsArrayItem(BsonDocument bsonDocument, string collectionName, ObjectId objectId, string fieldName)
{
if (objectId != ObjectId.Empty)
{
logger.LogTrace("SetDocumentAsArrayItem not empty", fieldName, objectId);
var IdsArray = new BsonArray();
IdsArray.Add(objectId);
bsonDocument.SetExtended(collectionName, fieldName, IdsArray);
}
else
{
logger.LogTrace("SetDocumentAsArrayItem empty", fieldName, objectId);
bsonDocument.RemoveExtended(collectionName, fieldName);
}
}
private void BuildSpecimenOrder(BsonDocument bsonParent)
{
MongoCollection specimenOrderTable = this.m_SQLTransferDatabase.GetCollection <BsonDocument>("tblSpecimenOrder");
MongoCursor mongoCursor = specimenOrderTable.FindAs <BsonDocument>(Query.EQ("MasterAccessionNo", bsonParent.GetValue("MasterAccessionNo")));
BsonArray array = new BsonArray();
foreach (BsonDocument bsonChild in mongoCursor)
{
bsonChild.Add("AssemblyQualifiedName", typeof(YellowstonePathology.Business.Specimen.Model.SpecimenOrder).AssemblyQualifiedName);
array.Add(bsonChild);
this.BuildAliquotOrder(bsonChild);
}
bsonParent.Add("SpecimenOrderCollection", array);
}
private IMongoQuery WrapQuery()
{
BsonDocument formattedReadPreference = null;
if (_serverInstance.InstanceType == MongoServerInstanceType.ShardRouter &&
_readPreference.ReadPreferenceMode != ReadPreferenceMode.Primary)
{
BsonArray tagSetsArray = null;
if (_readPreference.TagSets != null)
{
tagSetsArray = new BsonArray();
foreach (var tagSet in _readPreference.TagSets)
{
var tagSetDocument = new BsonDocument();
foreach (var tag in tagSet)
{
tagSetDocument.Add(tag.Name, tag.Value);
}
tagSetsArray.Add(tagSetDocument);
}
}
if (tagSetsArray != null || _readPreference.ReadPreferenceMode != ReadPreferenceMode.SecondaryPreferred)
{
formattedReadPreference = new BsonDocument
{
{ "mode", MongoUtils.ToCamelCase(_readPreference.ReadPreferenceMode.ToString()) },
{ "tags", tagSetsArray, tagSetsArray != null } // optional
};
}
}
if (_cursor.Options == null && formattedReadPreference == null)
{
return(_cursor.Query);
}
else
{
var query = (_cursor.Query == null) ? (BsonValue) new BsonDocument() : BsonDocumentWrapper.Create(_cursor.Query);
var wrappedQuery = new QueryDocument
{
{ "$query", query },
{ "$readPreference", formattedReadPreference, formattedReadPreference != null }, // only if sending query to a mongos
};
wrappedQuery.Merge(_cursor.Options);
return(wrappedQuery);
}
}
public BsonDocument MapViewModelToDocument(Dnd35CharacterViewModel character)
{
var bsonCharacter = new BsonDocument
{
{ characterName, character.CharacterName },
{ isShared, character.IsShared },
{ system, character.System.ToString() }
};
var classesArray = new BsonArray();
foreach (var classLevel in character.Classes)
{
classesArray.Add(new BsonDocument
{
{ className, classLevel.ClassName },
{ level, classLevel.Level }
});
}
bsonCharacter.Add(new BsonElement(classes, classesArray));
MapValue(character.Ecl, bsonCharacter, ecl);
MapValue(character.Race, bsonCharacter, race);
MapValue(character.Alignment, bsonCharacter, alignment);
MapValue(character.Diety, bsonCharacter, diety);
MapValue(character.Size, bsonCharacter, size);
MapValue(character.Age, bsonCharacter, age);
MapValue(character.Gender, bsonCharacter, gender);
MapValue(character.Height, bsonCharacter, height);
MapValue(character.Weight, bsonCharacter, weight);
MapValue(character.Eyes, bsonCharacter, eyes);
MapValue(character.Hair, bsonCharacter, hair);
MapValue(character.Skin, bsonCharacter, skin);
MapValue(character.Strength, bsonCharacter, strength);
MapValue(character.Dexterity, bsonCharacter, dexterity);
MapValue(character.Constitution, bsonCharacter, constitution);
MapValue(character.Intelligence, bsonCharacter, intelligence);
MapValue(character.Wisdom, bsonCharacter, wisdom);
MapValue(character.Charisma, bsonCharacter, charisma);
if (character.CharacterID != null)
{
var objectId = ObjectId.Parse(character.CharacterID);
bsonCharacter.Add(new BsonElement("_id", objectId));
}
return(bsonCharacter);
}
//Adds a dislike to an existing post document
public static void AddDislike(BsonDocument document, string id, string collectionName)
{
bool userDislike = false;
var collection = ConnectToDB("Acebook", collectionName);
BsonArray like = (BsonArray)document.GetValue("Like");
BsonArray dislike = (BsonArray)document.GetValue("Dislike");
var filter = Builders <BsonDocument> .Filter.Eq("_id", document.GetValue("_id"));
var newDocument = new BsonDocument {
{ "user", id }
};
foreach (var i in dislike)
{
if (i == newDocument)
{
userDislike = true;
}
}
if (userDislike != true)
{
dislike.Add(newDocument);
Tuple <BsonValue, int> item = SearchThroughLike(like, id);
BsonValue userId = item.Item1;
int index = item.Item2;
if (userId != null)
{
RemoveLike(like, collection, index, filter);
}
var update = Builders <BsonDocument> .Update.Set("Dislike", dislike);
collection.UpdateOne(filter, update);
}
else
{
Tuple <BsonValue, int> item = SearchThroughDislike(dislike, id);
int index = item.Item2;
RemoveDislike(dislike, collection, index, filter);
}
}
public static void ReadMongoGis(int total)
{
MongoClient client = new MongoClient(Utils.MongoDbConnection); // connect to localhost
MongoServer server = client.GetServer();
MongoDatabase test = server.GetDatabase("mydb");
var collection = test.GetCollection("address");
Random ran = new Random(DateTime.Now.Millisecond);
Console.WriteLine();
for (int i = 0; i < total; i++)
{
Console.Write("\r{0:N2}% ", (i + 1) / Convert.ToDouble(total) * 100);
var poly = GetRandomPolygon(ran);
var points = new BsonArray();
foreach (var item in poly.Coordinates)
{
points.Add(new BsonArray(new[] { item.X, item.Y }));
}
BsonDocument polygon = new BsonDocument
{
{ "type", "Polygon" },
{ "coordinates", new BsonArray()
{
{ points }
} },
};
BsonDocument gemotry = new BsonDocument {
{ "$geometry", polygon }
};
BsonDocument geoWithin = new BsonDocument {
{ "$geoWithin", gemotry }
};
var r = collection.FindAs <AddressMongo>(new QueryDocument()
{
{ "Coordinates", geoWithin }
})
.Count();
}
Console.WriteLine();
}
public void addAlert2UserTest()
{
WellCastServerEngine mm = new WellCastServerEngine();
User user = new User();
user.ID = "542c53a302d6a4910db3fdd7";
BsonArray forecastIDs = new BsonArray();
string id1 = Guid.NewGuid().ToString();
string id2 = Guid.NewGuid().ToString();
forecastIDs.Add(id1);
forecastIDs.Add(id2);
MongoDatabase mdb;
//Get a Reference to the Client Object
var mongoClient = new MongoClient("mongodb://*****:*****@ds041140.mongolab.com:41140/wellcast");
var mongoServer = mongoClient.GetServer();
mdb = mongoServer.GetDatabase("wellcast");
var queryDoc2 = new QueryDocument { { "state", "unsent" } };
// Query the db for a document with the required ID
var alertsUnSent0 = mdb.GetCollection("alerts").Find(queryDoc2);
long alerts0 = alertsUnSent0.Count();
mm.addAlert2User(user, forecastIDs);
var alertsUnSent1 = mdb.GetCollection("alerts").Find(queryDoc2);
long alerts1 = alertsUnSent1.Count();
Assert.AreEqual(alerts1, alerts0 + 1);
}
