public Question Save(Question question)
{
var questionsList = mongoDatabase.GetCollection("Questions");
WriteConcernResult result;
bool hasError = false;
if (string.IsNullOrEmpty(question._Id))
{
question._Id = ObjectId.GenerateNewId().ToString();
result = questionsList.Insert <Question>(question);
hasError = result.HasLastErrorMessage;
}
else
{
IMongoQuery query = Query.EQ("_id", question._Id);
IMongoUpdate update = Update
.Set("Body", question.Body)
.Set("Votes", question.Votes);
result = questionsList.Update(query, update);
hasError = result.HasLastErrorMessage;
}
if (!hasError)
{
return(question);
}
else
{
throw new Exception("");
}
}
public IHttpActionResult UpdateUser(Favorites fav)
{
var collection = mongoDb.GetCollection <Users>("Users");
IMongoQuery query = Query.EQ("UserName", fav.User);
var cursor = collection.FindOne(query);
var res = cursor.Favorites.Select(p => p.AsBsonArray);
var favCount = res.Count();
fav.Id = favCount + 1;
//fav.Category = fav.Category.First().ToString().ToUpper() + fav.Category.Substring(1);
BsonArray test = new BsonArray
{
fav.Id,
fav.Category,
fav.From,
fav.To
};
IMongoUpdate update = Update
.Push("Favorites", test);
result = collection.Update(query, update);
return(Ok(fav.Id + ' ' + fav.User + ' ' + fav.Category + ' ' + fav.From + ' ' + fav.To));
}
public void Delete(object entity)
{
var request = (DeleteCareTeamDataRequest)entity;
using (var ctx = new ContactCareTeamMongoContext(_dbName))
{
var queries = new List <IMongoQuery>
{
MB.Query <MEContactCareTeam> .EQ(c => c.Id, ObjectId.Parse(request.Id)),
MB.Query <MEContactCareTeam> .EQ(c => c.DeleteFlag, false)
};
var query = MB.Query.And(queries);
var contactCareTeam = ctx.CareTeam.Collection.FindOne(query);
var builder = new List <MB.UpdateBuilder>();
builder.Add(MB.Update.Set(MEContactCareTeam.TTLDateProperty, DateTime.UtcNow.AddDays(_expireDays)));
builder.Add(MB.Update.Set(MEContactCareTeam.DeleteFlagProperty, true));
builder.Add(MB.Update.Set(MEContactCareTeam.LastUpdatedOnProperty, DateTime.UtcNow));
builder.Add(MB.Update.Set(MEContactCareTeam.LastUpdatedByProperty, ObjectId.Parse(this.UserId)));
IMongoUpdate update = MB.Update.Combine(builder);
ctx.CareTeam.Collection.Update(query, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.CareTeam.ToString(),
contactCareTeam.Id.ToString(),
DataAuditType.Delete,
request.ContractNumber);
}
}
protected long UpdateAll(QueryOptions options, IMongoUpdate update, bool sendNotifications = true)
{
var result = _collection.Update(options.GetMongoQuery(_getIdValue), update, UpdateFlags.Multi);
if (!sendNotifications || !EnableNotifications || _messagePublisher == null)
{
return(result.DocumentsAffected);
}
if (options.OrganizationIds.Any())
{
foreach (var orgId in options.OrganizationIds)
{
PublishMessage(new EntityChanged {
ChangeType = ChangeType.UpdatedAll,
OrganizationId = orgId,
Type = _entityType
});
}
}
else
{
PublishMessage(new EntityChanged {
ChangeType = ChangeType.UpdatedAll,
Type = _entityType
});
}
return(result.DocumentsAffected);
}
public HttpResponseMessage PostAddRequest(User user)
{
ObjectId requestId = ObjectId.Parse(user.Name);
var login = (CustomMembershipUser)Membership.GetUser(User.Identity.Name);
MongoHelper <User> mongo = new MongoHelper <User>();
try
{
RequestsList req = new RequestsList();
req.UserId = requestId;
req.isViewd = false;
IMongoQuery query = Query.EQ("_id", requestId);
IMongoUpdate update = MongoDB.Driver.Builders.Update.PushWrapped("RequestsLists", req);
mongo.Collection.Update(query, update);
var userIdentity = mongo.Collection.Find(Query.EQ("_id", requestId)).SingleOrDefault();
var context = GlobalHost.ConnectionManager.GetHubContext <Request>();
context.Clients.Client(userIdentity.loginUserIdentity).addNewMessageToPage("Request", "You have friend request");
return(Request.CreateResponse(HttpStatusCode.OK, true));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.OK, false));
}
//return true;
}
public void Save(DeviceUpgradeSummary entity)
{
try
{
IMongoQuery query = Query.And
(
Query <DeviceUpgradeSummary> .EQ <DateTime>(mem => mem.Date, entity.Date),
Query <DeviceUpgradeSummary> .EQ <Guid>(mem => mem.ApplicationId, entity.ApplicationId),
Query <DeviceUpgradeSummary> .EQ <string>(mem => mem.Version, entity.Version),
Query <DeviceUpgradeSummary> .EQ <PlatformType>(mem => mem.PlatformType, entity.PlatformType)
);
IMongoUpdate update = Update <DeviceUpgradeSummary>
.SetOnInsert(x => x.Version, entity.Version)
.SetOnInsert(x => x.Date, entity.Date)
.SetOnInsert(x => x.ApplicationId, entity.ApplicationId)
.SetOnInsert(x => x.PlatformType, entity.PlatformType)
.Inc(mem => mem.Count, entity.Count);
this.GetCollection <DeviceUpgradeSummary>().FindAndModify(query, SortBy.Null, update, false, true);
}
catch (Exception ex)
{
throw new DataAccessLayerException(ex);
}
}
/// <summary>
/// Bulk update based on MongoQuery and MongoUpdate(low level querying patterns).
/// To process by a queue please set IMongoQuery and IMongoUpdate queries yourself, as in all other Insert and update operations
/// you set the particular Entity. Though I've never seen people updating in bulk in most business scenarios.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="update"></param>
/// <returns></returns>
public virtual long BulkUpdate <T>(IMongoQuery query, IMongoUpdate update) where T : IMXEntity
{
var collectionName = typeof(T).Name;
var collection = DbContext.GetCollection <T>(collectionName);
var bulk = collection.InitializeOrderedBulkOperation();
var updateBuilder = (UpdateBuilder <T>)update;
if (!IsProcessedByQueue)
{
//set defaults
updateBuilder.Inc(c => c.Version, 1);
updateBuilder.Set(c => c.CreatedBy, CurrentUser);
updateBuilder.Set(c => c.CreatedDate, CurrentDate);
}
bulk.Find(query).Update(updateBuilder);
var modifiedCount = bulk.Execute(WriteConcern.Acknowledged).ModifiedCount;
var docs = collection.FindAs <T>(query).ToList();
//Insert into history
Task.Run(() =>
InsertManyIntoHistory <T>(docs)
);
return(modifiedCount);
}
public string UpdateDocument(AdminData adminData)
{
try
{
MongoDatabase myDB = GetDB();
MongoCollection <AdminData> adminDataTable = myDB.GetCollection <AdminData>("AdminData");
QueryDocument queryDoc = new QueryDocument("_id", adminData._id);
IMongoQuery query = queryDoc;
// IMongoUpdate update = new UpdateDocument("Address","Hyd");
// IMongoUpdate update = new UpdateDocument().Set("Address", "Hyd") as UpdateDocument;
// IMongoUpdate update = new UpdateDocument().Set(queryDoc.IndexOfName("Address"), "Hyd") as UpdateDocument;
var updateDoc = Update.Set("Address", adminData.Address).Set("Age", adminData.Age.ToString()).Set("Name", adminData.Name).Set("SlNo", adminData.SlNo.ToString());
IMongoUpdate update = updateDoc;
WriteConcernResult updateResult = adminDataTable.Update(query, update);
return("Succcess");
// adminDataTable.Update()
// GetCollection();
}
catch (Exception ex)
{
throw;
}
}
public Tag Save(Tag tag)
{
var tagsList = mongoDatabase.GetCollection("Tags");
WriteConcernResult result;
bool hasError = false;
if (string.IsNullOrEmpty(tag._Id))
{
tag._Id = ObjectId.GenerateNewId().ToString();
result = tagsList.Insert <Tag>(tag);
hasError = result.HasLastErrorMessage;
}
else
{
IMongoQuery query = Query.EQ("_id", tag._Id);
IMongoUpdate update = Update
.Set("TagName", tag.TagName);
result = tagsList.Update(query, update);
hasError = result.HasLastErrorMessage;
}
if (!hasError)
{
return(tag);
}
else
{
throw new Exception("");
}
}
public void Update(IMongoQuery query, IMongoUpdate update)
{
GetTypeCollection <TEntity>(MappingCfg.ToDatabase, MappingCfg.ToCollection)
.Update(query, update, new MongoUpdateOptions {
Flags = UpdateFlags.Upsert
});
}
public void SignUp(Users newUser)
{
var collection = mongoDb.GetCollection <Users>("TestCollection"); //testing
//var collection = mongoDb.GetCollection<Users>("Users");
WriteConcernResult result;
var count = collection.Find(Query.EQ("UserName", newUser.UserName)).Count();
if (count > 0)
{
HttpResponseMessage httpResponse = new HttpResponseMessage(HttpStatusCode.BadRequest);
throw new HttpResponseException(httpResponse);
}
else
{
newUser.Id = ObjectId.GenerateNewId().ToString();
newUser.Favorites = new BsonArray();
newUser.Recents = new BsonArray();
BsonArray recent = new BsonArray(newUser.Recents);
IMongoUpdate update = Update
.Set("UserName", newUser.UserName)
.Set("Password", newUser.Password)
.Set("Email", newUser.Email)
.Set("Favorites", newUser.Favorites)
.Set("Recents", recent);
result = collection.Insert <Users>(newUser);
}
}
public void Update_Street_Information(Class_Street _Obj)
{
MongoCollection<Class_Street> Collection_ = Database_.GetCollection<Class_Street>("Street");
IMongoQuery Marker = Query.EQ("Id", _Obj.Id);
IMongoUpdate Update_ = MongoDB.Driver.Builders.Update.Set("STREETNM", _Obj.STREETNM);
Collection_.Update(Marker, Update_);
}
/// <summary>
/// reset package queues with airingId
/// </summary>
/// <param name="queueNames">The queue names.</param>
/// <param name="airingId">The airing id.</param>
/// <param name="destinationCode">The destination code</param>
public void ResetFor(IList <string> queueNames, string airingId, string destinationCode)
{
IMongoQuery query = Query.EQ("AssetId", airingId);
if (!string.IsNullOrEmpty(destinationCode))
{
query = Query.And(query, Query.EQ("Flights.Destinations.Name", destinationCode));
}
var currentAiring = _currentAirings.FindOne(query);
if (currentAiring == null)
{
return;
}
IList <ChangeNotification> changeNotifications = GetChangeNotifications(queueNames, currentAiring);
List <UpdateBuilder> updateValues = new List <UpdateBuilder>();
updateValues.Add(Update.PullAllWrapped("DeliveredTo", changeNotifications.Select(e => e.QueueName)));
updateValues.Add(Update.PullAllWrapped("IgnoredQueues", changeNotifications.Select(e => e.QueueName)));
updateValues.Add(Update.AddToSetEachWrapped("ChangeNotifications", changeNotifications.AsEnumerable()));
IMongoUpdate update = Update.Combine(updateValues);
_currentAirings.Update(query, update);
}
public DbDataset Save(DbDataset data)
{
var contactsList = mongoDatabase.GetCollection("Data");
WriteConcernResult result;
bool hasError = false;
if (string.IsNullOrEmpty(data.Id))
{
data.Id = ObjectId.GenerateNewId().ToString();
result = contactsList.Insert <DbDataset>(data);
hasError = result.HasLastErrorMessage;
}
else
{
IMongoQuery query = Query.EQ("_id", data.Id);
IMongoUpdate update = Update
.Set("Size", data.Size)
.Set("Circumference", data.Circumference)
.Set("Width", data.Width);
result = contactsList.Update(query, update);
hasError = result.HasLastErrorMessage;
}
if (!hasError)
{
return(data);
}
else
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public void Save(CrashSummary entity)
{
try
{
IMongoQuery query = Query.And
(
Query <CrashSummary> .EQ <DateTime>(mem => mem.Date, entity.Date),
Query <CrashSummary> .EQ <Guid>(mem => mem.ApplicationId, entity.ApplicationId),
Query <CrashSummary> .EQ <string>(mem => mem.Version, entity.Version),
Query <CrashSummary> .EQ <PlatformType>(mem => mem.PlatformId, entity.PlatformId)
);
IMongoUpdate update = Update <CrashSummary>
.SetOnInsert(x => x.Version, entity.Version)
.SetOnInsert(x => x.Date, entity.Date)
.SetOnInsert(x => x.ApplicationId, entity.ApplicationId)
.SetOnInsert(x => x.PlatformId, entity.PlatformId)
.Inc(mem => mem.Count, entity.Count);
this.GetCollection <CrashSummary>().FindAndModify(query, SortBy.Descending("Date"), update, false, true);
this.GetCollection <CrashSummary>().EnsureIndex(IndexKeys.Descending("Date"));
}
catch (Exception ex)
{
throw new DataAccessLayerException(ex);
}
}
public virtual Task <T> UpdateAsync(T entity)
{
return(Task.Run(() =>
{
WriteConcernResult result;
IMongoQuery query = Query <T> .EQ(arg => arg.Id, entity.Id);
IMongoUpdate update = Update.Replace(entity);
try
{
result = Collection.Update(query, update);
}
catch (MongoWriteConcernException e)
{
throw HandleWriteException(e);
}
catch (Exception e)
{
throw new ApplicationException("Mongo driver failure.", e);
}
CheckWriteResult(result, true);
return entity;
}));
}
public void UndoDelete(object entity)
{
try
{
if (entity != null)
{
using (PatientNoteMongoContext ctx = new PatientNoteMongoContext(ContractDBName))
{
string id = entity.ToString();
var q = MB.Query <MEPatientUtilization> .EQ(b => b.Id, ObjectId.Parse(id));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientUtilization.TTLDateProperty, BsonNull.Value));
uv.Add(MB.Update.Set(MEPatientUtilization.DeleteFlagProperty, false));
uv.Add(MB.Update.Set(MEPatientUtilization.LastUpdatedOnProperty, DateTime.UtcNow));
uv.Add(MB.Update.Set(MEPatientUtilization.UpdatedByProperty, ObjectId.Parse(this.UserId)));
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientUtilizations.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientUtilization.ToString(),
id,
DataAuditType.UndoDelete,
ContractDBName);
}
}
}
catch (Exception) { throw; }
}
public void UndoDelete(object entity)
{
UndoDeleteTaskDataRequest request = (UndoDeleteTaskDataRequest)entity;
try
{
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
var q = MB.Query <MEPatientTask> .EQ(b => b.Id, ObjectId.Parse(request.TaskId));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientTask.TTLDateProperty, BsonNull.Value));
uv.Add(MB.Update.Set(MEPatientTask.DeleteFlagProperty, false));
uv.Add(MB.Update.Set(MEPatientTask.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientTask.LastUpdatedOnProperty, DateTime.UtcNow));
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientTasks.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientTask.ToString(),
request.TaskId.ToString(),
Common.DataAuditType.UndoDelete,
request.ContractNumber);
}
}
catch (Exception) { throw; }
}
public Contact Save(Contact contact)
{
var contactsList = mongoDatabase.GetCollection("Contacts");
WriteConcernResult result;
bool hasError = false;
if (string.IsNullOrEmpty(contact.Id))
{
contact.Id = ObjectId.GenerateNewId().ToString();
result = contactsList.Insert <Contact>(contact);
hasError = result.HasLastErrorMessage;
}
else
{
IMongoQuery query = Query.EQ("_id", contact.Id);
IMongoUpdate update = Update
.Set("Name", contact.Name)
.Set("Address", contact.Address)
.Set("Phone", contact.Phone)
.Set("Email", contact.Email);
result = contactsList.Update(query, update);
hasError = result.HasLastErrorMessage;
}
if (!hasError)
{
return(contact);
}
else
{
throw new Exception("");
}
}
public void Delete(object entity)
{
DeleteCareMemberByPatientIdDataRequest request = (DeleteCareMemberByPatientIdDataRequest)entity;
try
{
using (CareMemberMongoContext ctx = new CareMemberMongoContext(_dbName))
{
var query = MB.Query <MECareMember> .EQ(b => b.Id, ObjectId.Parse(request.Id));
var builder = new List <MB.UpdateBuilder>();
builder.Add(MB.Update.Set(MECareMember.TTLDateProperty, DateTime.UtcNow.AddDays(_expireDays)));
builder.Add(MB.Update.Set(MECareMember.DeleteFlagProperty, true));
builder.Add(MB.Update.Set(MECareMember.LastUpdatedOnProperty, DateTime.UtcNow));
builder.Add(MB.Update.Set(MECareMember.UpdatedByProperty, ObjectId.Parse(this.UserId)));
IMongoUpdate update = MB.Update.Combine(builder);
ctx.CareMembers.Collection.Update(query, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.CareMember.ToString(),
request.Id.ToString(),
Common.DataAuditType.Delete,
request.ContractNumber);
}
}
catch (Exception) { throw; }
}
public void RemoveProgram(object entity, List <string> updatedProgramIds)
{
RemoveProgramInToDosDataRequest request = (RemoveProgramInToDosDataRequest)entity;
try
{
List <ObjectId> ids = updatedProgramIds.ConvertAll(r => ObjectId.Parse(r));
using (SchedulingMongoContext ctx = new SchedulingMongoContext(_dbName))
{
var q = MB.Query <METoDo> .EQ(b => b.Id, ObjectId.Parse(request.ToDoId));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.SetWrapped <List <ObjectId> >(METoDo.ProgramProperty, ids));
uv.Add(MB.Update.Set(METoDo.LastUpdatedOnProperty, DateTime.UtcNow));
uv.Add(MB.Update.Set(METoDo.UpdatedByProperty, ObjectId.Parse(this.UserId)));
IMongoUpdate update = MB.Update.Combine(uv);
ctx.ToDos.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.ToDo.ToString(),
request.ToDoId.ToString(),
Common.DataAuditType.Update,
request.ContractNumber);
}
}
catch (Exception) { throw; }
}
public bool blnUpdateDocument(string strCollectionName, IMongoQuery query, IMongoUpdate update)
{
const string udcErrorMethod = "blnUpdateDocument";
bool blnReturn = false;
try
{
if (!(string.IsNullOrWhiteSpace(strMongoDataBase)) && !(string.IsNullOrWhiteSpace(strCollectionName)))
{
WriteConcernResult objWrite = objMdbServer.GetDatabase(strMongoDataBase).GetCollection(strCollectionName).Update(query, update, WriteConcern.Acknowledged);
blnReturn = objWrite.Ok;
}
else
{
strException = "MongoDataBaseName and MongoCollection Name is Null or Void";
clsLog.blnLogError("clsMongoDBEngine", "bsonReadDocument", strException, "");
}
}
catch (Exception ex)
{
strException = ex.Message;
clsLog.blnLogError(udcErrorSource, udcErrorMethod, strException, "DNF Error");
}
return(blnReturn);
}
public void PushDeliveredTo(string airingId, string queueName)
{
var query = new QueryDocument {
{ "AssetId", airingId }
};
var pullDeliverTo = Update.PullAllWrapped("DeliverTo", queueName);
var pullIgnoredQueues = Update.PullAllWrapped("IgnoredQueues", queueName);
var pushDeliveredTo = Update.PushAllWrapped("DeliveredTo", queueName);
var pullNotificationUpdate = Update.Pull("ChangeNotifications",
new BsonDocument()
{
{ "QueueName", queueName }
});
List <UpdateBuilder> updateValues = new List <UpdateBuilder>
{
pullDeliverTo,
pullIgnoredQueues,
pushDeliveredTo,
pullNotificationUpdate
};
IMongoUpdate allUpdate = Update.Combine(updateValues);
_airings.Update(query, allUpdate, UpdateFlags.Multi);
}
public void Update(IMongoQuery query, IMongoUpdate update, string dbName, string collectionName)
{
GetTypeCollection <TEntity>(dbName, collectionName)
.Update(query, update, new MongoUpdateOptions {
Flags = UpdateFlags.Upsert
});
}
public void UndoDelete(object entity)
{
UndoDeleteCareTeamDataRequest request = (UndoDeleteCareTeamDataRequest)entity;
try
{
using (var ctx = new ContactCareTeamMongoContext(_dbName))
{
var query = MB.Query <MEContactCareTeam> .EQ(b => b.Id, ObjectId.Parse(request.Id));
var builder = new List <MB.UpdateBuilder>();
builder.Add(MB.Update.Set(MEContactCareTeam.TTLDateProperty, BsonNull.Value));
builder.Add(MB.Update.Set(MEContactCareTeam.DeleteFlagProperty, false));
builder.Add(MB.Update.Set(MEContactCareTeam.LastUpdatedOnProperty, DateTime.UtcNow));
builder.Add(MB.Update.Set(MEContactCareTeam.LastUpdatedByProperty, ObjectId.Parse(this.UserId)));
IMongoUpdate update = MB.Update.Combine(builder);
ctx.CareTeam.Collection.Update(query, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.CareMember.ToString(),
request.Id.ToString(),
Common.DataAuditType.UndoDelete,
request.ContractNumber);
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 根据文档名称更新指定内容
/// </summary>
/// <param name="colName">文档名称</param>
/// <param name="query">查询条件</param>
/// <param name="update">更新内容</param>
/// <param name="updateFlags">更新类型(upsert：如果不存在插入)</param>
/// <typeparam name="T"></typeparam>
public static void Update <T>(string colName, IMongoQuery query, IMongoUpdate update, UpdateFlags updateFlags)
{
var mongo = MongoManager.getDB();
var collection = mongo.GetCollection <T>(colName);
collection.Update(query, update, updateFlags);
}
public HttpResponseMessage PostLikePost(Temp temp)
{
ObjectId PostId = ObjectId.Parse(temp.Name1);
var login = (CustomMembershipUser)Membership.GetUser(User.Identity.Name);
MongoHelper <UserPost> mongoPost = new MongoHelper <UserPost>();
IMongoQuery query = Query.EQ("_id", PostId);
var post = mongoPost.Collection.Find(query).SingleOrDefault();
var id = post.LikeLists.Where(e => e == login.UserId).SingleOrDefault();
if (id.Pid == 0)
{
IMongoUpdate update = MongoDB.Driver.Builders.Update.PushWrapped("LikeLists", login.UserId);
mongoPost.Collection.Update(query, update);
}
else
{
IMongoUpdate update = MongoDB.Driver.Builders.Update.Pull("LikeLists", login.UserId);
mongoPost.Collection.Update(query, update);
}
return(Request.CreateResponse(HttpStatusCode.OK, true));
}
public void CreateContact(Contact newContact)
{
try
{
_mongoDatabase = RetreiveMongohqDb();
var contactsList = _mongoDatabase.GetCollection("ContactList");
WriteConcernResult result;
var hasError = false;
if (string.IsNullOrEmpty(newContact.Id))
{
newContact.Id = ObjectId.GenerateNewId().ToString();
result = contactsList.Insert(newContact);
hasError = result.HasLastErrorMessage;
}
else
{
var query = Query.EQ("_id", newContact.Id);
IMongoUpdate update = Update
.Set("Name", newContact.Name)
.Set("Address", newContact.Address)
.Set("Phone", newContact.Phone)
.Set("Email", newContact.Email);
result = contactsList.Update(query, update);
//hasError = result.HasLastErrorMessage;
}
}
catch (Exception ex)
{
throw;
}
}
public HttpResponseMessage PostAddComment(Temp temp)
{
ObjectId PostId = ObjectId.Parse(temp.Name1);
var login = (CustomMembershipUser)Membership.GetUser(User.Identity.Name);
MongoHelper <UserPost> mongoPost = new MongoHelper <UserPost>();
Comment comm = new Comment();
comm._id = ObjectId.GenerateNewId();
comm.Text = temp.Text;
comm.UserId = login.UserId;
comm.CreatedAt = DateTime.Now;
comm.LikeLists = new List <ObjectId>();
IMongoQuery query = Query.EQ("_id", PostId);
IMongoUpdate update = MongoDB.Driver.Builders.Update.PushWrapped("Comments", comm);
mongoPost.Collection.Update(query, update);
return(Request.CreateResponse(HttpStatusCode.OK, new {
commentId = comm._id.ToString(),
totalLikes = 0,
text = comm.Text,
createdAt = comm.CreatedAt.ToString("dd MMM yyyy HH:mm")
}));
}
public void Delete(object entity)
{
DeleteInterventionDataRequest request = (DeleteInterventionDataRequest)entity;
try
{
using (PatientGoalMongoContext ctx = new PatientGoalMongoContext(_dbName))
{
var q = MB.Query <MEPatientIntervention> .EQ(b => b.Id, ObjectId.Parse(request.InterventionId));
var uv = new List <MB.UpdateBuilder>();
uv.Add(MB.Update.Set(MEPatientIntervention.TTLDateProperty, System.DateTime.UtcNow.AddDays(_expireDays)));
uv.Add(MB.Update.Set(MEPatientIntervention.DeleteFlagProperty, true));
uv.Add(MB.Update.Set(MEPatientIntervention.UpdatedByProperty, ObjectId.Parse(this.UserId)));
uv.Add(MB.Update.Set(MEPatientIntervention.LastUpdatedOnProperty, DateTime.UtcNow));
IMongoUpdate update = MB.Update.Combine(uv);
ctx.PatientInterventions.Collection.Update(q, update);
AuditHelper.LogDataAudit(this.UserId,
MongoCollectionName.PatientIntervention.ToString(),
request.InterventionId.ToString(),
Common.DataAuditType.Delete,
request.ContractNumber);
}
}
catch (Exception) { throw; }
}
public Guid ExecuteStartImpl(string collectionName, object query, IMongoUpdate update, ExecuteType type)
{
var id = Guid.NewGuid();
var q = String.Format("{0}\n{1}", query, update);
var mongoTiming = new MongoTiming(collectionName, q, type, Profiler);
_inProgress[id] = mongoTiming;
return id;
}
// constructors
internal MongoUpdateMessage(BsonBinaryWriterSettings writerSettings, string collectionFullName, bool checkUpdateDocument, UpdateFlags flags, IMongoQuery query, IMongoUpdate update)
: base(MessageOpcode.Update, null, writerSettings)
{
this.collectionFullName = collectionFullName;
this.checkUpdateDocument = checkUpdateDocument;
this.flags = flags;
this.query = query;
this.update = update;
}
internal MongoUpdateMessage(
MongoConnection connection,
string collectionFullName,
UpdateFlags flags,
IMongoQuery query,
IMongoUpdate update
) :
base(connection, MessageOpcode.Update) {
this.collectionFullName = collectionFullName;
this.flags = flags;
this.query = query;
this.update = update;
}
public UpdateOperation(
string databaseName,
string collectionName,
BsonBinaryReaderSettings readerSettings,
BsonBinaryWriterSettings writerSettings,
WriteConcern writeConcern,
IMongoQuery query,
IMongoUpdate update,
UpdateFlags flags,
bool checkElementNames)
: base(databaseName, collectionName, readerSettings, writerSettings, writeConcern)
{
_query = query;
_update = update;
_flags = flags;
_checkElementNames = checkElementNames;
}
// constructors
internal MongoUpdateMessage(
BsonBinaryWriterSettings writerSettings,
string collectionFullName,
bool checkUpdateDocument,
UpdateFlags flags,
int maxDocumentSize,
IMongoQuery query,
IMongoUpdate update)
: base(MessageOpcode.Update, writerSettings)
{
_collectionFullName = collectionFullName;
_checkUpdateDocument = checkUpdateDocument;
_flags = flags;
_maxDocumentSize = maxDocumentSize;
_query = query;
_update = update;
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
foreach (var document in QueryCompiler.Query(Documents, Documents2, query, sortBy, 0, 0))
{
// if old is needed then deep(!) clone before update //_131103_185751
BsonDocument output = null;
if (!returnNew)
output = document.DeepClone().AsBsonDocument;
UpdateDocument(document, UpdateCompiler.GetFunction((IConvertibleToBsonDocument)update, null, false));
if (returnNew)
output = document;
// project
if (fields != null)
{
var project = FieldCompiler.GetFunction(fields);
output = project(output);
}
// if old is needed then return it as already deep cloned
result = new SimpleUpdateResult(1, true);
if (!returnNew && documentType == typeof(Dictionary))
return new Dictionary(output);
else
// deserialize to required type
return BsonSerializer.Deserialize(output, documentType);
}
// not found, insert
if (upsert)
{
var document = InsertNewDocument(query, update);
result = new SimpleUpdateResult(1, false);
return returnNew ? BsonSerializer.Deserialize(document, documentType) : null;
}
result = new SimpleUpdateResult(0, false);
return null;
}
/// <summary>
/// GEP 상품 업데이트
/// </summary>
/// <param name="query">IMongoQuery</param>
/// <param name="update">IMongoUpdate</param>
public void Update(IMongoQuery query , IMongoUpdate update)
{
List<GepItemsData> List = new List<GepItemsData>();
GEPMongoDacHelper MongoHelper = new GEPMongoDacHelper("gep", "gep_items");
MongoHelper.Save(query, update);
}
internal void UpdateGEPOrderInfo(IMongoQuery query, IMongoUpdate update)
{
new MongoDacHelper(GepMongoEnv.ConfigSection.GEP, GepMongoEnv.Database.GEP, GepMongoEnv.Collection.GEP_ORDER)
.Save(query, update, SafeMode.True);
}
public WriteConcernResult Update(IMongoQuery query, IMongoUpdate update, UpdateFlags flags, WriteConcern writeConcern, bool needResult)
{
return _this.Update(query, update, flags, writeConcern);
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
var r = _this.FindAndModify(query, sortBy, update, fields, returnNew, upsert);
result = new FindAndModifyUpdateResult(r);
return r.GetModifiedDocumentAs(documentType);
}
internal void UpdateeBayCancel(IMongoQuery query, IMongoUpdate update)
{
new MongoDacHelper(GepMongoEnv.ConfigSection.GEP, GepMongoEnv.Database.GEP_EBAY, GepMongoEnv.Collection.EBAY_CANCEL)
.Save(query, update, SafeMode.True);
}
Guid IMongoDbProfiler.ExecuteStart(string collectionName, IMongoQuery query, IMongoUpdate update, ExecuteType executeType)
{
return MongoProfiler.ExecuteStart(collectionName, query, update, executeType);
}
public bool UpdateObject(string objectName, IMongoQuery query, IMongoUpdate update)
{
WriteConcernResult result = Database.GetCollection(objectName).Update(query, update);
return result.Ok;
}
public static Guid ExecuteStart(this MongoProfiler mongoProfiler, string collectionName, object query, IMongoUpdate update, ExecuteType type)
{
if (mongoProfiler == null) return Guid.Empty;
return mongoProfiler.ExecuteStartImpl(collectionName, query, update, type);
}
public object FindAndModifyAs(Type documentType, IMongoQuery query, IMongoSortBy sortBy, IMongoUpdate update, IMongoFields fields, bool returnNew, bool upsert, out UpdateResult result)
{
var args = new FindAndModifyArgs();
args.Query = query;
args.SortBy = sortBy;
args.Update = update;
args.Fields = fields;
args.Upsert = upsert;
args.VersionReturned = returnNew ? FindAndModifyDocumentVersion.Modified : FindAndModifyDocumentVersion.Original;
var r = _this.FindAndModify(args);
result = new FindAndModifyUpdateResult(r);
return r.GetModifiedDocumentAs(documentType);
}
public WriteConcernResult Update(IMongoQuery query, IMongoUpdate update, UpdateFlags flags, WriteConcern writeConcern, bool needResult)
{
bool updatedExisting = false;
int documentsAffected = 0;
try
{
Func<BsonDocument, UpdateCompiler> function = null;
foreach (var document in QueryDocuments(query))
{
if (function == null)
function = UpdateCompiler.GetFunction((IConvertibleToBsonDocument)update, null, false);
UpdateDocument(document, function);
updatedExisting = true;
++documentsAffected;
if ((flags & UpdateFlags.Multi) == 0)
break;
}
// not found and upsert
if (function == null && (flags & UpdateFlags.Upsert) > 0)
{
InsertNewDocument(query, update);
++documentsAffected;
}
return needResult ? new WriteConcernResult(NewResponse(documentsAffected, updatedExisting, null, null)) : null;
}
catch (Exception ex)
{
throw new MongoWriteConcernException(ex.Message, new WriteConcernResult(NewResponse(documentsAffected, updatedExisting, ex.Message, null)));
}
}
public void TestUpdateOneKeyValidation(bool ordered)
{
var updates = new IMongoUpdate[]
{
new UpdateDocument { { "key", 1 } },
new UpdateDocument { { "key", 1 }, { "$key", 1 } }
};
foreach (var update in updates)
{
_collection.Drop();
var bulk = InitializeBulkOperation(_collection, ordered);
var query = Query.EQ("_id", 1);
bulk.Find(query).UpdateOne(update);
Assert.Throws<BsonSerializationException>(() => bulk.Execute());
}
}
// Inserts a new document created from a query and an update and returns it.
BsonDocument InsertNewDocument(IMongoQuery query, IMongoUpdate update)
{
var document = new BsonDocument();
UpdateCompiler.GetFunction((IConvertibleToBsonDocument)update, (IConvertibleToBsonDocument)query, true)(document);
InsertInternal(document);
return document;
}
/// <summary>
/// TA 토큰 업데이트로 사용
/// </summary>
/// <param name="query">조건 쿼리</param>
/// <param name="update">업데이트 쿼리</param>
public void TaTokenExpireDateUpdate(IMongoQuery query, IMongoUpdate update)
{
GEPMongoDacHelper MongoHelper = new GEPMongoDacHelper("gep", "ta");
MongoHelper.Save(query, update);
}
/// <summary>
/// eBay 상품정보 부분 저장
/// </summary>
public void Save(IMongoQuery query, IMongoUpdate update)
{
GEPMongoDacHelper MongoHelper = new GEPMongoDacHelper(dataBase, collection);
MongoHelper.Save(query, update);
}
/// <summary>
/// 修改
/// </summary>
public static bool Update(string collectionName, IMongoQuery query, IMongoUpdate newDoc)
{
MongoCollection<BsonDocument> collection;
MongoServer server = CreateMongoServer(collectionName, out collection);
try
{
collection.Update(query, newDoc);
//server.Disconnect();
return true;
}
catch
{
//server.Disconnect();
return false;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UpdateRequest"/> class.
/// </summary>
/// <param name="query">The query.</param>
/// <param name="update">The update.</param>
public UpdateRequest(IMongoQuery query, IMongoUpdate update)
: base(WriteRequestType.Update)
{
_query = query;
_update = update;
}
