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)); }