public void Change(ObjectId id, UpdateDefinition<BsonDocument> changeDefinition)
{
var result = _mongoCollection
.UpdateOne("{_id:ObjectId(\"" + id + "\")}", changeDefinition);
if (result.MatchedCount == 0)
{
throw new ArgumentException("no document was found with an id of \"" + id + "\"");
}
if (result.ModifiedCount == 0)
{
throw new ArgumentException("the document was not modified");
}
}
private static async Task HandleIncomingMessage(Socket socket, int offset, int size)
{
try
{
if (size <= 0)
{
return;
}
using (MemoryStream stream = new MemoryStream(receiveBuffers[socket], offset, size))
{
using (BinaryReader reader = new BinaryReader(stream, Encoding.UTF8, true))
{
byte messageType = reader.ReadByte();
if (messageType == (byte)MessageType.RegisterServer)
{
Console.WriteLine("[Register] Started");
// Parse contract
Dictionary <string, ContractValue> contractValues = new Dictionary <string, ContractValue>();
int valueCount = reader.ReadInt32();
for (int i = 0; i < valueCount; i++)
{
ulong nameHash = reader.ReadUInt64();
ContractType type = (ContractType)reader.ReadByte();
if (contracts.TryGetValue(nameHash, out ContractDefinition definition) && definition.Type == type)
{
object boxedValue = null;
switch (definition.Type)
{
case ContractType.Int8:
boxedValue = (long)reader.ReadSByte();
break;
case ContractType.Int16:
boxedValue = (long)reader.ReadInt16();
break;
case ContractType.Int32:
boxedValue = (long)reader.ReadInt32();
break;
case ContractType.Int64:
boxedValue = (long)reader.ReadInt32();
break;
case ContractType.UInt8:
boxedValue = (long)reader.ReadByte();
break;
case ContractType.UInt16:
boxedValue = (long)reader.ReadUInt16();
break;
case ContractType.UInt32:
boxedValue = (long)reader.ReadUInt32();
break;
case ContractType.UInt64:
boxedValue = (long)reader.ReadUInt64();
break;
case ContractType.String:
boxedValue = reader.ReadString();
break;
case ContractType.Buffer:
boxedValue = reader.ReadBytes(reader.ReadInt32());
break;
case ContractType.Guid:
boxedValue = new Guid(reader.ReadString());
break;
}
if (boxedValue != null)
{
contractValues.Add(definition.Name, new ContractValue()
{
Definition = definition,
Value = boxedValue
});
}
}
else
{
switch (type)
{
case ContractType.Int8:
reader.ReadSByte();
break;
case ContractType.Int16:
reader.ReadInt16();
break;
case ContractType.Int32:
reader.ReadInt32();
break;
case ContractType.Int64:
reader.ReadInt32();
break;
case ContractType.UInt8:
reader.ReadByte();
break;
case ContractType.UInt16:
reader.ReadUInt16();
break;
case ContractType.UInt32:
reader.ReadUInt32();
break;
case ContractType.UInt64:
reader.ReadUInt64();
break;
case ContractType.String:
reader.ReadString();
break;
case ContractType.Buffer:
reader.ReadBytes(reader.ReadInt32());
break;
case ContractType.Guid:
reader.ReadString();
break;
}
}
}
// Contract validation, ensure all REQUIRED fields are present
for (int i = 0; i < configuration.ServerContract.Length; i++)
{
if (configuration.ServerContract[i].Required)
{
if (!contractValues.TryGetValue(configuration.ServerContract[i].Name, out ContractValue contractValue) || contractValue.Definition.Type != configuration.ServerContract[i].Type)
{
// Failure, contract did not match
using (MemoryStream outStream = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(outStream, Encoding.UTF8, true))
{
writer.Write((byte)MessageType.RegisterAck);
writer.Write(new Guid().ToString());
writer.Write(false);
}
socket.BeginSend(outStream.GetBuffer(), 0, (int)outStream.Length, SocketFlags.None, (e) =>
{
socket.EndSend(e);
}, null);
}
Console.WriteLine("[Register] Registrar broke contract. Missing required field \"" + configuration.ServerContract[i].Name + "\" of type " + configuration.ServerContract[i].Type);
return;
}
}
}
List <ContractValue> validatedValues = new List <ContractValue>();
// Remove all fields not part of contract
for (int i = 0; i < configuration.ServerContract.Length; i++)
{
if (contractValues.TryGetValue(configuration.ServerContract[i].Name, out ContractValue contractValue) && contractValue.Definition.Type == configuration.ServerContract[i].Type)
{
validatedValues.Add(contractValue);
}
}
// Create model for DB
ServerModel server = new ServerModel()
{
Id = Guid.NewGuid().ToString(),
LastPingTime = DateTime.UtcNow,
Address = ((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6(),
ContractData = new Dictionary <string, object>()
};
// Add contract values to model
for (int i = 0; i < validatedValues.Count; i++)
{
server.ContractData.Add(validatedValues[i].Definition.Name, validatedValues[i].Value);
}
if (configuration.VerbosePrints)
{
Console.WriteLine("[Register] Adding: " + JsonConvert.SerializeObject(server));
}
else
{
Console.WriteLine("[Register] Adding 1 server");
}
if (configuration.UseMongo)
{
// Insert model to DB
await mongoClient.GetDatabase(configuration.MongoDatabase).GetCollection <ServerModel>("servers").InsertOneAsync(server);
}
else
{
localModels.Add(server);
}
using (MemoryStream outStream = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(outStream, Encoding.UTF8, true))
{
writer.Write((byte)MessageType.RegisterAck);
writer.Write(server.Id);
writer.Write(true);
}
socket.BeginSend(outStream.GetBuffer(), 0, (int)outStream.Length, SocketFlags.None, (e) =>
{
socket.EndSend(e);
}, null);
}
}
else if (messageType == (byte)MessageType.Query)
{
DateTime startTime = DateTime.Now;
Console.WriteLine("[Query] Started");
string guid = reader.ReadString();
string query = reader.ReadString();
Console.WriteLine("[Query] Parsing");
JObject parsedQuery = JObject.Parse(query);
List <ServerModel> serverModel = null;
if (configuration.UseMongo)
{
Console.WriteLine("[Query] Creating mongo filter");
FilterDefinition <ServerModel> filter = Builders <ServerModel> .Filter.And(Builders <ServerModel> .Filter.Where(x => x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout)), QueryParser.CreateFilter(new List <JToken>()
{
parsedQuery
}));
if (configuration.VerbosePrints)
{
Console.WriteLine("[Query] Executing mongo query \"" + mongoClient.GetDatabase(configuration.MongoDatabase).GetCollection <ServerModel>("servers").Find(filter) + "\"");
}
else
{
Console.WriteLine("[Query] Executing mongo query");
}
serverModel = await(await mongoClient.GetDatabase(configuration.MongoDatabase).GetCollection <ServerModel>("servers").FindAsync(filter)).ToListAsync();
}
else
{
Console.WriteLine("[Query] Querying local");
serverModel = localModels.AsParallel().Where(x => x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout) && QueryParser.FilterLocalServers(new List <JToken>()
{
parsedQuery
}, x)).ToList();
}
Console.WriteLine("[Query] Found " + (serverModel == null ? 0 : serverModel.Count) + " results. Total query time: " + (DateTime.Now - startTime).TotalMilliseconds + " ms");
using (MemoryStream outStream = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(outStream, Encoding.UTF8, true))
{
writer.Write((byte)MessageType.QueryResponse);
writer.Write(guid);
writer.Write(serverModel.Count);
for (int i = 0; i < serverModel.Count; i++)
{
writer.Write(serverModel[i].Id);
writer.Write(serverModel[i].Address.MapToIPv6().GetAddressBytes());
writer.Write(serverModel[i].LastPingTime.ToBinary());
writer.Write(serverModel[i].ContractData.Count);
foreach (KeyValuePair <string, object> pair in serverModel[i].ContractData)
{
writer.Write(pair.Key);
writer.Write((byte)contracts[pair.Key.GetStableHash64()].Type);
switch (contracts[pair.Key.GetStableHash64()].Type)
{
case ContractType.Int8:
writer.Write((sbyte)(long)pair.Value);
break;
case ContractType.Int16:
writer.Write((short)(long)pair.Value);
break;
case ContractType.Int32:
writer.Write((int)(long)pair.Value);
break;
case ContractType.Int64:
writer.Write((long)pair.Value);
break;
case ContractType.UInt8:
writer.Write((byte)(long)pair.Value);
break;
case ContractType.UInt16:
writer.Write((ushort)(long)pair.Value);
break;
case ContractType.UInt32:
writer.Write((uint)(long)pair.Value);
break;
case ContractType.UInt64:
writer.Write((ulong)(long)pair.Value);
break;
case ContractType.String:
writer.Write((string)pair.Value);
break;
case ContractType.Buffer:
writer.Write(((byte[])pair.Value).Length);
writer.Write((byte[])pair.Value);
break;
case ContractType.Guid:
writer.Write(((Guid)pair.Value).ToString());
break;
}
}
}
}
socket.BeginSend(outStream.GetBuffer(), 0, (int)outStream.Length, SocketFlags.None, (e) =>
{
socket.EndSend(e);
}, null);
}
}
else if (messageType == (byte)MessageType.ServerAlive)
{
Console.WriteLine("[Alive] Started");
Guid guid = new Guid(reader.ReadString());
if (configuration.VerbosePrints)
{
Console.WriteLine("[Alive] Parsed from " + guid.ToString());
}
else
{
Console.WriteLine("[Alive] Parsed");
}
if (configuration.UseMongo)
{
// Find and validate address ownership
FilterDefinition <ServerModel> filter = Builders <ServerModel> .Filter.And(Builders <ServerModel> .Filter.Where(x => x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout)), Builders <ServerModel> .Filter.Eq(x => x.Address, ((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6()), Builders <ServerModel> .Filter.Eq(x => x.Id, guid.ToString()));
// Create update
UpdateDefinition <ServerModel> update = Builders <ServerModel> .Update.Set(x => x.LastPingTime, DateTime.UtcNow);
// Execute
await mongoClient.GetDatabase(configuration.MongoDatabase).GetCollection <ServerModel>("servers").FindOneAndUpdateAsync(filter, update);
}
else
{
ServerModel model = localModels.Find(x => x.Address.Equals(((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6()) && x.Id == guid.ToString() && x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout));
if (model != null)
{
model.LastPingTime = DateTime.UtcNow;
}
}
}
else if (messageType == (byte)MessageType.RemoveServer)
{
Console.WriteLine("[Remove] Started");
Guid guid = new Guid(reader.ReadString());
if (configuration.VerbosePrints)
{
Console.WriteLine("[Remove] Parsed from " + guid.ToString());
}
else
{
Console.WriteLine("[Remove] Parsed");
}
ServerModel model = null;
if (configuration.UseMongo)
{
// Find and validate address ownership
FilterDefinition <ServerModel> filter = Builders <ServerModel> .Filter.And(Builders <ServerModel> .Filter.Where(x => x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout)), Builders <ServerModel> .Filter.Eq(x => x.Address, ((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6()), Builders <ServerModel> .Filter.Eq(x => x.Id, guid.ToString()));
// Execute
model = await mongoClient.GetDatabase(configuration.MongoDatabase).GetCollection <ServerModel>("servers").FindOneAndDeleteAsync(filter);
}
else
{
model = localModels.Find(x => x.Id == guid.ToString() && x.Address.Equals(((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6()));
if (model != null)
{
localModels.Remove(model);
}
}
if (model != null)
{
if (configuration.VerbosePrints)
{
Console.WriteLine("[Remove] Removed: " + JsonConvert.SerializeObject(model));
}
else
{
Console.WriteLine("[Remove] Removed 1 element");
}
}
else
{
Console.WriteLine("[Remove] Not found");
}
}
else if (messageType == (byte)MessageType.UpdateServer)
{
Console.WriteLine("[Update] Started");
Guid guid = new Guid(reader.ReadString());
ServerModel result = null;
if (configuration.UseMongo)
{
result = await(await mongoClient.GetDatabase(configuration.MongoDatabase).GetCollection <ServerModel>("servers").FindAsync(x => x.Id == guid.ToString() && x.Address == ((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6() && x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout))).FirstOrDefaultAsync();
}
else
{
result = localModels.Find(x => x.Id == guid.ToString() && x.Address.Equals(((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6()) && x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout));
}
if (result != null)
{
// Parse contract
Dictionary <string, ContractValue> contractValues = new Dictionary <string, ContractValue>();
int valueCount = reader.ReadInt32();
for (int i = 0; i < valueCount; i++)
{
ulong nameHash = reader.ReadUInt64();
ContractType type = (ContractType)reader.ReadByte();
if (contracts.TryGetValue(nameHash, out ContractDefinition definition) && definition.Type == type)
{
object boxedValue = null;
switch (definition.Type)
{
case ContractType.Int8:
boxedValue = (long)reader.ReadSByte();
break;
case ContractType.Int16:
boxedValue = (long)reader.ReadInt16();
break;
case ContractType.Int32:
boxedValue = (long)reader.ReadInt32();
break;
case ContractType.Int64:
boxedValue = (long)reader.ReadInt64();
break;
case ContractType.UInt8:
boxedValue = (long)reader.ReadByte();
break;
case ContractType.UInt16:
boxedValue = (long)reader.ReadUInt16();
break;
case ContractType.UInt32:
boxedValue = (long)reader.ReadUInt32();
break;
case ContractType.UInt64:
boxedValue = (long)reader.ReadUInt64();
break;
case ContractType.String:
boxedValue = reader.ReadString();
break;
case ContractType.Buffer:
boxedValue = reader.ReadBytes(reader.ReadInt32());
break;
case ContractType.Guid:
boxedValue = new Guid(reader.ReadString());
break;
}
if (boxedValue != null)
{
contractValues.Add(definition.Name, new ContractValue()
{
Definition = definition,
Value = boxedValue
});
}
}
else
{
switch (type)
{
case ContractType.Int8:
reader.ReadSByte();
break;
case ContractType.Int16:
reader.ReadInt16();
break;
case ContractType.Int32:
reader.ReadInt32();
break;
case ContractType.Int64:
reader.ReadInt64();
break;
case ContractType.UInt8:
reader.ReadByte();
break;
case ContractType.UInt16:
reader.ReadUInt16();
break;
case ContractType.UInt32:
reader.ReadUInt32();
break;
case ContractType.UInt64:
reader.ReadUInt64();
break;
case ContractType.String:
reader.ReadString();
break;
case ContractType.Buffer:
reader.ReadBytes(reader.ReadInt32());
break;
case ContractType.Guid:
reader.ReadString();
break;
}
}
}
// Contract validation, ensure all REQUIRED fields are present
for (int i = 0; i < configuration.ServerContract.Length; i++)
{
if (configuration.ServerContract[i].Required)
{
if (!contractValues.TryGetValue(configuration.ServerContract[i].Name, out ContractValue contractValue) || contractValue.Definition.Type != configuration.ServerContract[i].Type)
{
// Failure, contract did not match
return;
}
}
}
List <ContractValue> validatedValues = new List <ContractValue>();
// Remove all fields not part of contract
for (int i = 0; i < configuration.ServerContract.Length; i++)
{
if (contractValues.TryGetValue(configuration.ServerContract[i].Name, out ContractValue contractValue) && contractValue.Definition.Type == configuration.ServerContract[i].Type)
{
validatedValues.Add(contractValue);
}
}
Dictionary <string, object> validatedLookupValues = new Dictionary <string, object>();
// Add contract values to model
for (int i = 0; i < validatedValues.Count; i++)
{
validatedLookupValues.Add(validatedValues[i].Definition.Name, validatedValues[i].Value);
}
if (configuration.UseMongo)
{
// Find and validate address ownership
FilterDefinition <ServerModel> filter = Builders <ServerModel> .Filter.And(Builders <ServerModel> .Filter.Where(x => x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout)), Builders <ServerModel> .Filter.Eq(x => x.Address, ((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6()), Builders <ServerModel> .Filter.Eq(x => x.Id, guid.ToString()));
// Create update
UpdateDefinition <ServerModel> update = Builders <ServerModel> .Update.Set(x => x.LastPingTime, DateTime.UtcNow).Set(x => x.ContractData, validatedLookupValues);
// Insert model to DB
await mongoClient.GetDatabase(configuration.MongoDatabase).GetCollection <ServerModel>("servers").FindOneAndUpdateAsync(filter, update);
}
else
{
ServerModel model = localModels.Find(x => x.Address.Equals(((IPEndPoint)socket.RemoteEndPoint).Address.MapToIPv6()) && x.Id == guid.ToString() && x.LastPingTime >= DateTime.UtcNow.AddMilliseconds(-configuration.ServerTimeout));
model.LastPingTime = DateTime.UtcNow;
model.ContractData = validatedLookupValues;
}
}
}
else if (messageType == (byte)MessageType.ContractCheck)
{
Console.WriteLine("[ContractCheck] Started");
string guid = reader.ReadString();
int contractCount = reader.ReadInt32();
WeakContractDefinition[] remoteContracts = new WeakContractDefinition[contractCount];
for (int i = 0; i < contractCount; i++)
{
remoteContracts[i] = new WeakContractDefinition()
{
Name = reader.ReadString(),
Type = (ContractType)reader.ReadByte()
};
}
using (MemoryStream outStream = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(outStream, Encoding.UTF8, true))
{
writer.Write((byte)MessageType.ContractResponse);
writer.Write(guid);
writer.Write(ContractDefinition.IsCompatible(remoteContracts, contracts.Select(x => x.Value).ToArray()));
}
socket.BeginSend(outStream.GetBuffer(), 0, (int)outStream.Length, SocketFlags.None, (e) =>
{
socket.EndSend(e);
}, null);
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <summary> /// Takes a document you want to modify and applies the update you have defined in MongoDb. /// </summary> /// <typeparam name="T">The type representing a Document</typeparam> /// <param name="collectionName">Name of collection in db (by default is name of T)</param> /// <param name="entityToModify">Db entity of type T</param> /// <param name="update">The update definition for the document</param> /// <returns></returns> public async Task UpdateOneAsync(T entityToModify, UpdateDefinition <T> update) => await DbContext.GetCollection <T>().UpdateOneAsync(x => x.Id.Equals(entityToModify.Id), update);
/// <summary>
/// 更新所有满足条件的所有数据
/// </summary>
/// <param name="collectionName">数据集名称</param>
/// <param name="filter">过滤条件</param>
/// <param name="update">更新内容</param>
/// <returns>更新结果</returns>
public UpdateResult UpdateMany(string collectionName, FilterDefinition <BsonDocument> filter, UpdateDefinition <BsonDocument> update)
{
return(GetCollection(collectionName).UpdateMany(filter, update));
}
public static bool UpdateField <T>(FilterDefinition <T> filter, UpdateDefinition <T> update) where T : Entity
{
return(GetCollection <T>().UpdateOneAsync(filter, update).Result.IsAcknowledged);
}
/// <summary>
/// 更新角色信息
/// </summary>
/// <param name="Query">查询条件</param>
/// <param name="Update">更新条件</param>
/// <returns>返回更新结果</returns>
public UpdateResult UpdateRole(BsonDocument Query, UpdateDefinition<BsonDocument> Update)
{
return dh.UpdateData("userroles", Query, Update);
}
public static void Update(EmployerSurvey survey, UpdateDefinition<EmployerSurvey> update)
{
DBContext.Current.Update<EmployerSurvey>(x => x.id == survey.id, update);
}
public TProjection FindOneAndUpdate <TProjection>(IClientSessionHandle session, FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, FindOneAndUpdateOptions <TDocument, TProjection> options = null, CancellationToken cancellationToken = default)
{
throw new System.NotImplementedException();
}
public abstract TProjection FindOneAndUpdate <TProjection>(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, FindOneAndUpdateOptions <TDocument, TProjection> options = null, CancellationToken cancellationToken = default(CancellationToken));
public virtual async Task <T> ModifyAsync(string correlationId, FilterDefinition <T> filterDefinition, UpdateDefinition <T> updateDefinition)
{
if (filterDefinition == null || updateDefinition == null)
{
return(default(T));
}
var options = new FindOneAndUpdateOptions <T>
{
ReturnDocument = ReturnDocument.After,
IsUpsert = false
};
var result = await _collection.FindOneAndUpdateAsync(filterDefinition, updateDefinition, options);
_logger.Trace(correlationId, "Modify in {0}", _collectionName);
return(result);
}
public Task <UpdateResult> UpdateManyAsync(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.FromResult(UpdateMany(filter, update, options, cancellationToken)));
}
/// <summary>
/// Altera assíncrono o registro na base de dados.
/// </summary>
/// <param name="filtro">Expressão LAMBDA.</param>
/// <param name="registro">Informe o objeto.</param>
/// <returns>Retorna o registro atualizado.</returns>
public virtual async Task <T> AlterarAsync(Expression <Func <T, bool> > filtro, UpdateDefinition <T> registro)
{
try
{
await BuscarAsync(filtro);
return(await Colecao.FindOneAndUpdateAsync(sessao, filtro, registro, opcaoPadrao));
}
catch (Exception)
{
throw;
}
}
public void Update(string id, UpdateDefinition <T> update)
{
this.Collection.UpdateOne(t => t.Id == id, update);
}
/// <summary>
/// 更新数据集中所有数据
/// </summary>
/// <param name="collectionName">数据集名称</param>
/// <param name="update">更新内容</param>
/// <returns>更新结果</returns>
public UpdateResult UpdateAll(string collectionName, UpdateDefinition <BsonDocument> update)
{
return(GetCollection(collectionName).UpdateMany(new BsonDocument(), update));
}
/// <summary>
/// 更新案件信息
/// </summary>
/// <param name="Query">查询条件</param>
/// <param name="Update">更新条件</param>
/// <returns>返回更新结果</returns>
public UpdateResult UpdateCase(BsonDocument Query, UpdateDefinition<BsonDocument> Update)
{
return dh.UpdateData("cases", Query, Update);
}
public UpdateResult UpdateOne(IClientSessionHandle session, FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options = null, CancellationToken cancellationToken = default)
{
throw new System.NotImplementedException();
}
public static void Update(PersonalSurvey survey, UpdateDefinition<PersonalSurvey> update)
{
DBContext.Current.Update<PersonalSurvey>(x => x.id == survey.id, update);
}
public abstract UpdateResult UpdateMany(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken));
public static void Update(User user, UpdateDefinition<User> update)
{
DBContext.Current.Update<User>(x => x.id == user.id, update);
}
public Task <TProjection> FindOneAndUpdateAsync <TProjection>(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, FindOneAndUpdateOptions <TDocument, TProjection> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(Task.FromResult(FindOneAndUpdate(filter, update, options, cancellationToken)));
}
public Task <TProjection> FindOneAndUpdateAsync <TProjection>(IClientSessionHandle session, FilterDefinition <T> filter, UpdateDefinition <T> update, FindOneAndUpdateOptions <T, TProjection> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
/// <summary>
/// 修改一条数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collection">表名</param>
/// <param name="filter">条件</param>
/// <param name="update">更新的数据</param>
/// <param name="upsert">如果它不存在是否插入文档</param>
/// <returns></returns>
public string UpdateOne <T>(string collection, Expression <Func <T, Boolean> > filter, UpdateDefinition <T> update, bool upsert)
{
UpdateResult result = Database.GetCollection <T>(collection).UpdateOne(filter, update, new UpdateOptions()
{
IsUpsert = upsert
});
return(result.ToJson());
}
public Task <UpdateResult> UpdateOneAsync(IClientSessionHandle session, FilterDefinition <T> filter, UpdateDefinition <T> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
/// <summary>
/// 修改一条数据
/// </summary>
/// <param name="collection">表名</param>
/// <param name="filter">条件</param>
/// <param name="update">更新的数据</param>
/// <param name="upsert">如果它不存在是否插入文档</param>
/// <returns></returns>
public async Task <string> UpdateOneAsync(string collection, Expression <Func <BsonDocument, Boolean> > filter, UpdateDefinition <BsonDocument> update, bool upsert)
{
UpdateResult result = await Database.GetCollection <BsonDocument>(collection).UpdateOneAsync(filter, update, new UpdateOptions()
{
IsUpsert = upsert
});
return(result.ToJson());
}
private BsonDocument RenderUpdate <TDocument>(UpdateDefinition <TDocument> update)
{
var serializer = BsonSerializer.SerializerRegistry.GetSerializer <TDocument>();
return(update.Render(serializer, BsonSerializer.SerializerRegistry));
}
/// <summary>
/// 修改文档
/// </summary>
/// <param name="collName">集合名称</param>
/// <param name="filter">修改条件</param>
/// <param name="update">修改结果</param>
/// <param name="upsert">是否插入新文档（filter条件满足就更新，否则插入新文档）</param>
/// <returns></returns>
public Int64 UpdateMany <T>(String collName, Expression <Func <T, Boolean> > filter, UpdateDefinition <T> update, Boolean upsert = false)
{
UpdateResult result = Database.GetCollection <T>(collName).UpdateMany(filter, update, new UpdateOptions {
IsUpsert = upsert
});
return(result.ModifiedCount);
}
public override async Task <UpdateResult> Update(StuffItem item)
{
if (item.Id.HasValue) // update
{
var updateitem = await Get(item.Id.Value.ToString());
if (updateitem != null)
{
var builder = Builders <StuffItem> .Update;
UpdateDefinition <StuffItem> update = null;
// обновляем только те поля, которые изменились
if (item.Name?.ToLower() != StuffItem.Undefined)
{
update = builder.Set(p => p.Name, item.Name);
}
if (item.Description?.ToLower() != StuffItem.Undefined)
{
update = update == null
? builder.Set(p => p.Description, item.Description)
: update.Set(p => p.Description, item.Description);
}
if (item.Tags != null && item.Tags.Count > 0)
{
await Task.Run(() =>
{
var id = 0;
foreach (var tag in item.Tags)
{
tag.Id = ++id;
tag.StuffId = item.Id.Value;
}
});
update = update == null
? builder.Set(p => p.Tags, item.Tags)
: update.Set(p => p.Tags, item.Tags);
}
if (update != null) //есть, что обновить
{
var doc = Document;
if (doc != null)
{
return(await doc.UpdateOneAsync(Builders <StuffItem> .Filter.Eq(p => p.Id, item.Id), update));
}
}
}
}
else //Add new
{
if (item.Name?.ToLower() == StuffItem.Undefined)
{
item.Name = null;
}
if (item.Description?.ToLower() == StuffItem.Undefined)
{
item.Description = null;
}
await Add(item);
}
return(null);
}
/// <summary>
/// 修改多个文档
/// </summary>
/// <param name="collName">集合名称</param>
/// <param name="filter">修改条件</param>
/// <param name="update">修改结果</param>
/// <param name="upsert">是否插入新文档（filter条件满足就更新，否则插入新文档）</param>
/// <returns></returns>
public async Task <long> UpdateManyAsync(String collName, Expression <Func <BsonDocument, Boolean> > filter, UpdateDefinition <BsonDocument> update, Boolean upsert = false)
{
UpdateResult result = await Database.GetCollection <BsonDocument>(collName).UpdateManyAsync(filter, update, new UpdateOptions {
IsUpsert = upsert
});
return(result.ModifiedCount);
}
/// <summary> /// Takes a document you want to modify and applies the update you have defined in MongoDb with session /// </summary> /// <param name="entityToModify"></param> /// <param name="update"></param> /// <param name="session"></param> /// <typeparam name="T"></typeparam> /// <returns></returns> public async Task UpdateOneAsync(T entityToModify, UpdateDefinition <T> update, IClientSessionHandle session) => await DbContext.GetCollection <T>().UpdateOneAsync(session, x => x.Id.Equals(entityToModify.Id), update);
/// <summary>
/// 修改文档
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collName">表名</param>
/// <param name="filter">条件</param>
/// <param name="update">更新后的数据</param>
/// <returns></returns>
public T UpdateOne <T>(String collName, Expression <Func <T, Boolean> > filter, UpdateDefinition <T> update)
{
T result = Database.GetCollection <T>(collName).FindOneAndUpdate(filter, update);
return(result);
}
/// <summary>
/// 更新邮件地址信息
/// </summary>
/// <param name="Query">查询条件</param>
/// <param name="Update">更新条件</param>
/// <returns>返回更新结果</returns>
public UpdateResult UpdateAddress(BsonDocument Query, UpdateDefinition<BsonDocument> Update)
{
return dh.UpdateData("MaillAddress", Query, Update);
}
/// <summary>
/// 修改文档
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="collName">表名</param>
/// <param name="filter">条件</param>
/// <param name="update">更新后的数据</param>
/// <returns></returns>
public async Task <T> UpdateOneAsync <T>(String collName, Expression <Func <T, Boolean> > filter, UpdateDefinition <T> update)
{
T result = await Database.GetCollection <T>(collName).FindOneAndUpdateAsync(filter, update);
return(result);
}
/// <summary>
/// 更新昵称信息
/// </summary>
/// <param name="Query">查询条件</param>
/// <param name="Update">更新条件</param>
/// <returns>返回更新结果</returns>
public UpdateResult UpdateNickName(BsonDocument Query, UpdateDefinition<BsonDocument> Update)
{
return dh.UpdateData("MaillNikeName", Query, Update);
}
/// <summary>
/// 修改文档
/// </summary>
/// <param name="collName">表名</param>
/// <param name="filter">条件</param>
/// <param name="update">更新后的Bson数据</param>
/// <returns></returns>
public async Task <BsonDocument> UpdateOneAsync(String collName, Expression <Func <BsonDocument, Boolean> > filter, UpdateDefinition <BsonDocument> update)
{
BsonDocument result = await Database.GetCollection <BsonDocument>(collName).FindOneAndUpdateAsync(filter, update);
return(result);
}
/// <summary>
/// 更新电话数据
/// </summary>
/// <param name="Query">查询条件</param>
/// <param name="Update">更新条件</param>
/// <returns>返回更新结果</returns>
public UpdateResult UpdatePhone(BsonDocument Query, UpdateDefinition<BsonDocument> Update)
{
return dh.UpdateData("MailPhone", Query, Update);
}
public TProjection FindOneAndUpdate <TProjection>(FilterDefinition <T> filter, UpdateDefinition <T> update, FindOneAndUpdateOptions <T, TProjection> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
/// <summary>
/// InsertManyAsync in the Collection
/// </summary>
/// <param name="departmentName"></param>
/// <param name="headOfDepartmentId"></param>
async private static void InsertManyAsync(string collectionName, UpdateDefinition<BsonDocument> bsonDocuments, BsonDocument filters)
{
IMongoDatabase myDB = Connection();
IMongoCollection<BsonDocument> collections = myDB.GetCollection<BsonDocument>(collectionName);
UpdateDefinition<BsonDocument> documentList = bsonDocuments;
await collections.UpdateManyAsync(filters , documentList);
}
public Task <TProjection> FindOneAndUpdateAsync <TProjection>(FilterDefinition <T> filter, UpdateDefinition <T> update, FindOneAndUpdateOptions <T, TProjection> options = null, CancellationToken cancellationToken = default(CancellationToken))
{
var id = filter.ToBsonDocument().GetValue("Document").ToBsonDocument().GetValue("_id").ToString();
if (items.ContainsKey(id))
{
// Hardcoded for incrementing Sequence
var foundItem = items[id];
var sourceItem = CloneObject(foundItem) as object;
var valuePropertyInfo = foundItem.GetType().GetRuntimeProperty("Value");
var currentValue = (int)valuePropertyInfo.GetValue(foundItem);
valuePropertyInfo.SetValue(foundItem, ++currentValue);
return(Task.FromResult((TProjection)sourceItem));
}
return(Task.FromResult((TProjection)(object)null));
}
public static void Update(JobExplorer jobExplorer, UpdateDefinition<JobExplorer> update)
{
DBContext.Current.Update<JobExplorer>(x => x.id == jobExplorer.id, update);
}
public UpdateResult UpdateOne(FilterDefinition <T> filter, UpdateDefinition <T> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
/// <summary>
/// 更新角色下用户不具有的权限
/// </summary>
/// <param name="Query">查询条件</param>
/// <param name="Update">跟新条件</param>
/// <returns>返回更新结果</returns>
public UpdateResult UpdateUserInRoleWithoutPower(BsonDocument Query, UpdateDefinition<BsonDocument> Update)
{
return dh.UpdateData("users", Query, Update);
}
public UpdateResult UpdateContainer(BsonDocument Query, UpdateDefinition<BsonDocument> Update)
{
return dh.UpdateData("MailContainer", Query, Update);
}
private void ParseUpdateModel(
BsonDocument model,
out FilterDefinition <BsonDocument> filter,
out UpdateDefinition <BsonDocument> update,
out List <ArrayFilterDefinition> arrayFilters,
out BsonValue hint,
out bool isUpsert)
{
arrayFilters = null;
filter = null;
update = null;
hint = null;
isUpsert = false;
foreach (BsonElement argument in model.Elements)
{
switch (argument.Name)
{
case "arrayFilters":
arrayFilters = argument
.Value
.AsBsonArray
.Cast <BsonDocument>()
.Select(x => new BsonDocumentArrayFilterDefinition <BsonValue>(x))
.ToList <ArrayFilterDefinition>();
break;
case "filter":
filter = new BsonDocumentFilterDefinition <BsonDocument>(argument.Value.AsBsonDocument);
break;
case "hint":
hint = argument.Value;
break;
case "update":
switch (argument.Value)
{
case BsonDocument:
update = argument.Value.AsBsonDocument;
break;
case BsonArray:
update = PipelineDefinition <BsonDocument, BsonDocument> .Create(argument.Value.AsBsonArray.Cast <BsonDocument>());
break;
default:
throw new FormatException($"Invalid BulkWrite Update model update argument: '{argument.Value}'.");
}
break;
case "upsert":
isUpsert = argument.Value.ToBoolean();
break;
default:
throw new FormatException($"Invalid BulkWrite Update model argument name: '{argument.Name}'.");
}
}
}
public void SetValue(string name, BsonValue value)
{
if(_updateDefinition == null)
{
_updateDefinition = Builders<BsonDocument>.Update.Set(name, value);
}
else
{
_updateDefinition = _updateDefinition.Set(name, value);
}
}
