public static UpdateDefinition <TDocument> CreateMongoUpdate(Action <IDocumentUpdateBuilder> update)
{
var builder = new MongoDocumentUpdateBuilder <TDocument>();
update?.Invoke(builder);
return((builder._updates.Count != 1) ? InternalBuilder.Combine(builder._updates) : builder._updates[0]);
}
public T UpdateOne <T>(Expression <Func <T, bool> > filter, T instance) where T : DbModel
{
if (instance == null)
{
return(null);
}
var doc = this.Document <T>();
List <UpdateDefinition <T> > updates = new List <UpdateDefinition <T> >();
MongoDB.Driver.UpdateDefinitionBuilder <T> builder = new UpdateDefinitionBuilder <T>();
Type t = instance.GetType();
var ps = t.GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var p in ps)
{
if (p.Name == "Id")
{
continue;
}
updates.Add(builder.Set(p.Name, p.GetValue(instance)));
}
doc.UpdateOne(filter, builder.Combine(updates));
return(instance);
}
public static void InsertOrUpdateSubMsg(SubMsg subMsg)
{
var db = Conf.DbConfig.GetDataBase(Conf.BasicConfig.BaseMsg);
var coll = db.GetCollection <SubMsg>(Conf.BasicConfig.SubApp);
if (subMsg._id.Timestamp == 0)
{
subMsg.CreateTime = DateTime.Now;
subMsg.UpdateTime = DateTime.Now;
subMsg._id = new ObjectId();
coll.InsertOne(subMsg);
}
else
{
subMsg.UpdateTime = DateTime.Now;
var filter = Builders <SubMsg> .Filter.Eq(p => p._id, subMsg._id);
var updateBuilders = new UpdateDefinitionBuilder <SubMsg>();
var updateDefinition = updateBuilders.Combine(new[] {
Builders <SubMsg> .Update.Set(p => p.Enabled, subMsg.Enabled),
Builders <SubMsg> .Update.Set(p => p.ReceiveType, subMsg.ReceiveType),
Builders <SubMsg> .Update.Set(p => p.ReceiveContent, subMsg.ReceiveContent),
Builders <SubMsg> .Update.Set(p => p.UpdateTime, subMsg.UpdateTime)
});
coll.UpdateOne(filter, updateDefinition);
}
}
public static void InsertOrUpdateApp(App app)
{
var db = Conf.DbConfig.GetDataBase(Conf.BasicConfig.BaseMsg);
var coll = db.GetCollection <App>(Conf.BasicConfig.PubApp);
if (app._id.Timestamp == 0)
{
app.CreateTime = DateTime.Now;
app.UpdateTime = DateTime.Now;
app._id = new ObjectId();
coll.InsertOne(app);
}
else
{
app.UpdateTime = DateTime.Now;
var filter = Builders <App> .Filter.Eq(p => p._id, app._id);
var updateBuilders = new UpdateDefinitionBuilder <App>();
var updateDefinition = updateBuilders.Combine(new[] {
Builders <App> .Update.Set(p => p.Enabled, app.Enabled),
Builders <App> .Update.Set(p => p.Description, app.Description),
Builders <App> .Update.Set(p => p.UpdateTime, app.UpdateTime)
});
coll.UpdateOne(filter, updateDefinition, new UpdateOptions
{
BypassDocumentValidation = false
}
);
}
}
public UpdateDefinition <T> Build()
{
if (_defs.Count == 1)
{
return(_defs.Single());
}
return(_builder.Combine(_defs));
}
public static UpdateDefinition <TDocument> SetAllMappedMembers <TDocument>(
this UpdateDefinitionBuilder <TDocument> updateBuilder, TDocument item
, params Expression <Func <TDocument, object> >[] excludeMembers)
{
UpdateDefinition <TDocument> update = updateBuilder.Combine();
return(SetAllMappedMembers <TDocument>(update, item, excludeMembers));
}
private UpdateDefinition <TEntity> CreateUpdateDefinition(InternalEntityEntry internalEntityEntry)
{
var builder = new UpdateDefinitionBuilder <TEntity>();
IEntityType entityType = internalEntityEntry.EntityType;
IList <UpdateDefinition <TEntity> > updateDefinitions = entityType
.GetProperties()
.Where(property => property.PropertyInfo != null && internalEntityEntry.IsModified(property))
.Select(property => CreatePropertyUpdateDefinition(builder, internalEntityEntry, property))
.ToList();
return(builder.Combine(updateDefinitions));
}
protected override UpdateDefinition <TDerivedDocument> AdjustUpdateDefinition(UpdateDefinition <TDerivedDocument> updateDefinition, bool isUpsert)
{
var result = base.AdjustUpdateDefinition(updateDefinition, isUpsert);
if (isUpsert)
{
var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(TDerivedDocument));
var discriminatorValue = discriminatorConvention.GetDiscriminator(typeof(TRootDocument), typeof(TDerivedDocument));
var builder = new UpdateDefinitionBuilder <TDerivedDocument>();
var setOnInsertDiscriminator = builder.SetOnInsert(discriminatorConvention.ElementName, discriminatorValue);
result = builder.Combine(result, setOnInsertDiscriminator);
}
return(result);
}
public User UpdateUser(User user)
{
User OldUser = collection.Find(f => f.id == user.id).FirstOrDefault();
UpdateDefinitionBuilder <User> UpdateBuilder = Builders <User> .Update;
PropertyInfo[] UserProperties = user.GetType().GetProperties();
PropertyInfo[] OldUserProperties = OldUser.GetType().GetProperties();
UpdateDefinition <User> finalUpdate;
List <UpdateDefinition <User> > updates = new List <UpdateDefinition <User> >();
for (int i = 0; i < OldUserProperties.Length; i++)
{
if (UserProperties[i].GetValue(user) != null)
{
if (!UserProperties[i].GetValue(user).Equals(OldUserProperties[i].GetValue(OldUser)))
{
if (UserProperties[i].Name == "password")
{
HashPassword(user);
}
updates.Add(UpdateBuilder.Set(UserProperties[i].Name, UserProperties[i].GetValue(user)));
}
}
}
finalUpdate = UpdateBuilder.Combine(updates);
if (updates.Count > 0)
{
UpdateResult result = collection.UpdateOne(f => f.id == user.id, finalUpdate);
cacheService.Expire("user_" + user.id);
if (result.ModifiedCount > 0)
{
return(collection.Find(f => f.id == user.id).FirstOrDefault());
}
else
{
return(null);
}
}
else
{
return(null);
}
}
/// <summary>
/// Generates UpdateDefinition from anonimous type
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TAnon"></typeparam>
/// <param name="Object"></param>
/// <returns></returns>
public static UpdateDefinition <T> UpdateDefinitionFromAnonimous <T, TAnon> (object Object) where T : IEntity
{
UpdateDefinitionBuilder <T> upddb = Builders <T> .Update;
var l = new List <UpdateDefinition <T> >();
var props = typeof(T).GetProperties().Select(p => new KeyValuePair <string, Type> (p.Name, p.PropertyType));
var anonProps = typeof(TAnon).GetProperties();
foreach (var prop in anonProps)
{
var pkvp = props.FirstOrDefault(p => p.Key == prop.Name);
if (pkvp.Key != null && pkvp.Value == prop.PropertyType)
{
l.Add(upddb.Set(prop.Name, prop.GetValue(Object)));
}
}
return(upddb.Combine(l));
}
public void Update(User lastEntity, User newEntity)
{
var filter = Builders <User> .Filter.Eq("_id", lastEntity.Id);
var data = GetBy(lastEntity.Id);
UpdateDefinitionBuilder <User> updateDef = Builders <User> .Update;
var updates = new List <UpdateDefinition <User> >();
foreach (var prop in typeof(User).GetProperties())
{
if (prop.GetValue(newEntity) != null)
{
updates.Add(updateDef.Set(prop.Name, prop.GetValue(newEntity)));
}
}
_userCollection.UpdateOne(filter, updateDef.Combine(updates));
}
public async Task <Models.Domain.Device> Update(
Models.Domain.Device device,
CancellationToken cancellationToken)
{
var filter = new ExpressionFilterDefinition <Models.Domain.Device>(i =>
i.UserId == device.UserId &&
i.Id == device.Id);
var updateDefinition = new UpdateDefinitionBuilder <Models.Domain.Device>();
updateDefinition.Set(d => d.Name, device.Name);
updateDefinition.Set(d => d.ThingTypes, device.ThingTypes);
return(await _deviceCollection.FindOneAndUpdateAsync <Models.Domain.Device>(
filter,
updateDefinition.Combine(),
null,
cancellationToken));
}
public static UpdateDefinition <MusicDocument> BuildUpdateQuery(IMusicUpdateQuery query)
{
List <UpdateDefinition <MusicDocument> > updates = new List <UpdateDefinition <MusicDocument> >();
if (!string.IsNullOrEmpty(query.Album))
{
updates.Add(updateBuilder.Set(m => m.Album, query.Album));
}
if (!string.IsNullOrEmpty(query.Artist))
{
updates.Add(updateBuilder.Set(m => m.Artist, query.Artist));
updates.Add(updateBuilder.Set(m => m.ArtistAlphabetIndex, MusicHelper.CalculateAlphabetIndex(artistFirstChar: query.Artist[0])));
}
if (query.Length > 0)
{
updates.Add(updateBuilder.Set(m => m.Length, query.Length));
}
if (!string.IsNullOrEmpty(query.Path))
{
updates.Add(updateBuilder.Set(m => m.Path, query.Path));
}
if (!string.IsNullOrEmpty(query.Title))
{
updates.Add(updateBuilder.Set(m => m.Title, query.Title));
}
if (query.IsFavorite.HasValue)
{
updates.Add(updateBuilder.Set(m => m.IsFavorite, query.IsFavorite));
}
if (updates.Any())
{
updates.Add(updateBuilder.Set(m => m.UpdatedDate, DateTime.UtcNow));
}
return(updates.Any() ? updateBuilder.Combine(updates) : null);
}
public Item UpdateItem(Item item)
{
Item OldItem = collection.Find(f => f.id == item.id).FirstOrDefault();
UpdateDefinitionBuilder <Item> UpdateBuilder = Builders <Item> .Update;
PropertyInfo[] ItemProperties = item.GetType().GetProperties();
PropertyInfo[] OldItemProperties = OldItem.GetType().GetProperties();
UpdateDefinition <Item> finalUpdate;
List <UpdateDefinition <Item> > updates = new List <UpdateDefinition <Item> >();
for (int i = 0; i < OldItemProperties.Length; i++)
{
if (ItemProperties[i].GetValue(item) != null)
{
if (!ItemProperties[i].GetValue(item).Equals(OldItemProperties[i].GetValue(OldItem)))
{
updates.Add(UpdateBuilder.Set(ItemProperties[i].Name, ItemProperties[i].GetValue(item)));
}
}
}
finalUpdate = UpdateBuilder.Combine(updates);
if (updates.Count > 0)
{
UpdateResult result = collection.UpdateOne(f => f.id == item.id, finalUpdate);
if (result.ModifiedCount > 0)
{
cacheService.Expire("item_" + item.id);
return(collection.Find(f => f.id == item.id).FirstOrDefault());
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public void Update(TEntity entity, params string[] fields)
{
var idMap = GetIdValueMap(entity);
var updateFields = (fields ?? Array.Empty <string>()).Except(idMap.Select(p => p.Key)).ToList();
if (updateFields.Count > 0)
{
var filter = FilterBuilder.And(idMap.Select(kv => FilterBuilder.Eq(kv.Key, kv.Value)));
var updates = updateFields
.Select(p => UpdateBuilder.Set(p, typeof(TEntity).GetProperty(p).GetValue(entity))).ToList();
var allUpdates = UpdateBuilder.Combine(updates);
if (Context.Session != null)
{
Collection.UpdateOne(Context.Session, filter, allUpdates, new UpdateOptions());
}
else
{
Collection.UpdateOne(filter, allUpdates, new UpdateOptions());
}
}
}
public void Update <DocumentType>(DocumentType document)
{
BsonDocument localDocument = document.ToBsonDocument();
FilterDefinition <DocumentType> filter = Builders <DocumentType> .Filter.Eq("_id", localDocument["_id"]);
UpdateDefinition <DocumentType> update;
List <UpdateDefinition <DocumentType> > updateDefinitions = new List <UpdateDefinition <DocumentType> >();
UpdateDefinitionBuilder <DocumentType> updateBuilder = Builders <DocumentType> .Update;
List <string> names = localDocument.Names.ToList();
for (int bsonNameIndex = 1; bsonNameIndex < names.Count; bsonNameIndex++)
{
if (localDocument[names[bsonNameIndex]].GetType() != typeof(BsonArray))
{
updateDefinitions.Add(updateBuilder.Set(names[bsonNameIndex], localDocument[names[bsonNameIndex]]));
}
}
update = updateBuilder.Combine(updateDefinitions);
connectionManager.RetrieveCollection <DocumentType>().UpdateOne(filter, update);
}
public async Task <Type> Update(
Type type,
CancellationToken cancellationToken)
{
var filter = new ExpressionFilterDefinition <Type>(i =>
i.TenantId == type.TenantId &&
i.Id == type.Id);
var updateDefinition = new UpdateDefinitionBuilder <Type>();
updateDefinition.Set(d => d.Name, type.Name);
updateDefinition.Set(d => d.Icons, type.Icons);
updateDefinition.Set(d => d.Images, type.Images);
updateDefinition.Set(d => d.ActuatorValues, type.ActuatorValues);
updateDefinition.Set(d => d.SensorValues, type.SensorValues);
updateDefinition.Set(d => d.MessageProtocols, type.MessageProtocols);
updateDefinition.Set(d => d.ThingTypes, type.ThingTypes);
return(await _deviceCollection.FindOneAndUpdateAsync <Type>(
filter,
updateDefinition.Combine(),
null,
cancellationToken));
}
public static UpdateDefinition <TDocument> SetIfNotNull <TDocument, TField>(this UpdateDefinitionBuilder <TDocument> builder, Expression <Func <TDocument, TField> > field, TField value) =>
value == null
? builder.Combine()
: builder.Set(field, value);
public async Task <IConfigurationEntry> EnsureForEntry(string component, ConfigurationPath path, ConfigurationValue value, ConfigurationValueMeaning?meaning = null, string label = null, bool?visibleForPages = null)
{
var filterBuilder = new FilterDefinitionBuilder <MongoDbConfigurationDocument>();
if (string.IsNullOrWhiteSpace(component))
{
component = RootComponentName;
}
var pathFilter = filterBuilder.Eq(a => a.Path, path.ToString()) & filterBuilder.Eq(a => a.Component, component);
var entries = await settingsCollectionData.FindAsync(pathFilter);
bool creatingNow = false;
var entry = await entries.FirstOrDefaultAsync();
if (entry == null)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value), "Value is mandatory in EnsureForEntity operation when no configuration value found in database");
}
creatingNow = true;
entry = new MongoDbConfigurationDocument
{
Component = string.IsNullOrWhiteSpace(component) ? null : component,
Path = path,
ValueType = value.Type.ToString()
};
}
if (meaning.HasValue)
{
entry.Meaning = meaning.Value.ToString();
}
if (label != null)
{
entry.Label = label;
}
if (visibleForPages.HasValue)
{
entry.VisibleToPages = visibleForPages.Value;
}
if (creatingNow)
{
ApplyValueToConfigurationEntry(entry, value);
await settingsCollectionData.InsertOneAsync(entry);
}
else
{
var updateBuilder = new UpdateDefinitionBuilder <MongoDbConfigurationDocument>();
List <UpdateDefinition <MongoDbConfigurationDocument> > updates = new List <UpdateDefinition <MongoDbConfigurationDocument> >();
if (visibleForPages.HasValue)
{
entry.VisibleToPages = visibleForPages.Value;
updates.Add(updateBuilder.Set(a => a.VisibleToPages, entry.VisibleToPages));
}
if (!string.IsNullOrWhiteSpace(label))
{
entry.Label = label;
updates.Add(updateBuilder.Set(a => a.Label, label));
}
if (meaning.HasValue)
{
entry.Meaning = meaning.Value.ToString();
updates.Add(updateBuilder.Set(a => a.Meaning, meaning.ToString()));
}
if (value != null)
{
ApplyValueToConfigurationEntry(entry, value);
updates.Add(updateBuilder.Set(a => a.ValueType, entry.ValueType));
updates.Add(updateBuilder.Set(a => a.StringValue, entry.StringValue));
updates.Add(updateBuilder.Set(a => a.BooleanValue, entry.BooleanValue));
updates.Add(updateBuilder.Set(a => a.LongValue, entry.LongValue));
updates.Add(updateBuilder.Set(a => a.DoubleValue, entry.DoubleValue));
updates.Add(updateBuilder.Set(a => a.BytesValue, entry.BytesValue));
}
var builder = new FilterDefinitionBuilder <MongoDbConfigurationDocument>();
var filter = builder.Eq(a => a.Id, entry.Id);
await settingsCollectionData.UpdateOneAsync(filter, updateBuilder.Combine(updates));
foreach (var change in updates)
{
}
}
return(RebuildConfigurationEntry(entry));
}
/// <summary>
/// 修改对象
/// </summary>
/// <param name="entity">对象</param>
public virtual void Update(TEntity entity)
{
var updated = Updater.Combine(GeneratorMongoUpdate(entity));
this.collection.UpdateOne(Filter.Eq("_id", new ObjectId(entity.Id as string)), updated);
}
public async Task <IHttpActionResult> Post()
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls11;
HttpClient authClient = new HttpClient();
string oauthToken, serviceUrl;
int syncCount = 0;
//set system config variables
int sfdcSyncFrequency = Convert.ToInt32(ConfigurationManager.AppSettings["SalesforceSyncFrequency"]);
int sfdcBatchSize = Convert.ToInt32(ConfigurationManager.AppSettings["SalesforceSyncBatchSize"]);
//defined remote access app - develop --> remote access --> new
//set OAuth key and secret variables
string sfdcConsumerKey = ConfigurationManager.AppSettings["ConsumerKey"];
string sfdcConsumerSecret = ConfigurationManager.AppSettings["ConsumerSecret"];
//set to Force.com user account that has API access enabled
string sfdcUserName = ConfigurationManager.AppSettings["ForceUserName"];
string sfdcPassword = ConfigurationManager.AppSettings["ForcePassword"];
string sfdcToken = ConfigurationManager.AppSettings["ForceToken"];
//create login password value
string loginPassword = sfdcPassword + sfdcToken;
HttpContent content = new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "grant_type", "password" },
{ "client_id", sfdcConsumerKey },
{ "client_secret", sfdcConsumerSecret },
{ "username", sfdcUserName },
{ "password", loginPassword }
});
try
{
//print response values
RootObject sfdcJson = new RootObject();
sfdcJson.reqst = new Reqst();
sfdcJson.reqst.caseList = new List <CaseList>();
var unsynchedCases = Repository.All().Where(x => x.SyncStatus == 0).OrderBy(x => x.Timestamp).Take(sfdcBatchSize);
syncCount = unsynchedCases.Count();
if (syncCount == 0)
{
return(Ok(new { sync_frequency = sfdcSyncFrequency, sync_count = syncCount }));
}
foreach (var unsyncedCase in unsynchedCases)
{
sfdcJson.reqst.caseList.Add(new CaseList
{
origin = unsyncedCase.Origins,
status = unsyncedCase.Status,
subject = unsyncedCase.Subject,
MongoID__c = unsyncedCase.MongoId.ToString()
});
}
#region Salesforce Token Obtain
HttpResponseMessage message = await authClient.PostAsync(ConfigurationManager.AppSettings["SalesforceAuthUri"], content);
string responseString = await message.Content.ReadAsStringAsync();
JObject obj = JObject.Parse(responseString);
oauthToken = (string)obj["access_token"];
serviceUrl = (string)obj["instance_url"];
#endregion
#region SalesforceApi call
HttpContent postContent = new StringContent(JsonConvert.SerializeObject(sfdcJson), Encoding.UTF8, "application/json");
authClient.DefaultRequestHeaders.Add("Authorization", string.Format("Bearer {0}", oauthToken));
HttpResponseMessage responseMessage = await authClient.PostAsync(ConfigurationManager.AppSettings["SalesforceBulkCaseUri"], postContent);
if (responseMessage.StatusCode == HttpStatusCode.OK)
{
//var filter = Builders<Case>.Filter.In(x => x.Id, unsynchedCases.Select(x => x.Id));
//var update = Builders<Case>.Update.Set(x => x.SyncStatus, 1);
//Repository.UpdateMany(filter, update, null, new System.Threading.CancellationToken());
var responseJson = responseMessage.Content.ReadAsStringAsync().Result;
var result = JsonConvert.DeserializeObject <SfdcResponse>(responseJson);
Dictionary <string, string> dict = new Dictionary <string, string>();
foreach (var item in result.CaseRespList)
{
dict.Add(item.MongoID__c, item.CaseNumber);
}
foreach (var c in dict)
{
var filter = Builders <Case> .Filter.Eq("MongoId", c.Key);
//var update = Builders<Case>.Update.Set(x => x.CaseNumber, c.Value);
//update.AddToSet("SyncStatus",1);k
UpdateDefinitionBuilder <Case> updateBuilder = new UpdateDefinitionBuilder <Case>();
//updateBuilder.Set(x=>x.CaseNumber, c.Value);
//updateBuilder.Set(x=>x.SyncStatus, 1);
Repository.UpdateMany(filter, updateBuilder.Combine(Builders <Case> .Update.Set(x => x.CaseNumber, c.Value), Builders <Case> .Update.Set(x => x.SyncStatus, 1)), null, new System.Threading.CancellationToken());
}
#endregion
return(Ok(new { sync_frequency = sfdcSyncFrequency, sync_count = syncCount }));
}
return(Ok(new { sync_frequency = sfdcSyncFrequency, sync_count = syncCount }));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public UpdateDefinition <T> End()
{
return(_builder.Combine(_updates));
}
public void SaveOrUpdate <TEntity>(TEntity entity) where TEntity : class, IEntity, new()
{
var id = entity.TryGetValue("Id");
if (GetById <TEntity>(id) == null)
{
Save(entity);
return;
}
var update = new UpdateDefinitionBuilder <TEntity>();
foreach (var property in typeof(TEntity).GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(r => !r.Name.EqualsWithInvariant("Id")))
{
var value = property.GetValue(entity, null);
BsonValue bsonValue = BsonNull.Value;
if (value != null)
{
var type = (property.PropertyType.IsGenericType && property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))
? property.PropertyType.GetGenericArguments()[0]
: property.PropertyType;
if (type == typeof(string))
{
bsonValue = new BsonString(value.ToString());
}
else if (type == typeof(bool))
{
bsonValue = new BsonBoolean((bool)value);
}
else if (type == typeof(DateTime))
{
bsonValue = new BsonDateTime((DateTime)value);
}
else if (type == typeof(long))
{
bsonValue = new BsonInt64((long)value);
}
else if (type == typeof(int))
{
bsonValue = new BsonInt32((int)value);
}
else if (type == typeof(byte[]))
{
bsonValue = new BsonBinaryData((byte[])value);
}
else if (type == typeof(Guid))
{
bsonValue = new BsonBinaryData((Guid)value);
}
else if (type.IsEnum)
{
bsonValue = new BsonString(value.ToString());
}
else if (type.IsImplement <IEnumerable>())
{
bsonValue = new BsonArray(value as IEnumerable);
}
else if (type.IsClass && type.IsImplement <IEntity>())
{
bsonValue = new BsonDocumentWrapper(value);
}
else
{
throw new ArgumentOutOfRangeException("propertyType {0} does not bson value".F(type));
}
}
update.Set(property.Name, bsonValue);
}
GetCollection <TEntity>().UpdateMany(r => r.Id == id, update.Combine());
}
public UpdateDefinition <T> UpdateDefinition()
{
return(UpdateBuilder.Combine(Updates));
}
