コード例 #1
1
        private void CheckTimeout()
        {
            var watch = Stopwatch.StartNew();

            var timeout = Configuration.ProcessTimeout;

            // timeout can't be less than PollTime
            if (timeout < PollTime)
                timeout = PollTime;

            var timeoutDate = DateTime.UtcNow.Subtract(timeout);

            // all message that are processing and update before timeout date
            Expression<Func<Message, bool>> filter = m => m.State == MessageState.Processing && m.Updated < timeoutDate;

            var timeoutState = (Configuration.TimeoutPolicy == TimeoutPolicy.Retry)
                ? MessageState.Queued
                : MessageState.Timeout;

            // update all messages that are timed out
            var updateDefinition = Builders<Message>.Update
                .Set(m => m.State, timeoutState)
                .Set(p => p.Updated, DateTime.UtcNow)
                .Inc(p => p.ErrorCount, 1);

            var updateOptions = new UpdateOptions { IsUpsert = false };

            var t = Repository.Collection.UpdateManyAsync(
                filter,
                updateDefinition,
                updateOptions);

            // wait for result
            var result = t.Result;

            watch.Stop();

            // log as Warn if there are results
            Logger.Warn()
                .Message("Completed '{0}' timeout check in: {1} ms. Timeout Message Count: {2}", Name, watch.ElapsedMilliseconds, result.ModifiedCount)
                .WriteIf(result.ModifiedCount > 0);
        }
コード例 #2
0
        public Task SaveLinks(int nodeId, IEnumerable<NodeLink> links)
        {
            var nodeLinks = new NodeLinks(nodeId, links);
            var updateOptions = new UpdateOptions
            {
                IsUpsert = true
            };

            return _collection.ReplaceOneAsync(x => x.Id == nodeId, nodeLinks, updateOptions);
        }
コード例 #3
0
 public void AllocateBootstrapServer(int organisationID, BootstrapServer bootstrapServer)
 {
     IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
     IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("OrganisationBootstrapServer");
     FilterDefinition<BsonDocument> query = Builders<BsonDocument>.Filter.Eq("_id", organisationID);
     BsonDocument doc = new BsonDocument();
     BsonHelper.SetValue(doc, "_id", organisationID);
     BsonHelper.SetValue(doc, "Url", bootstrapServer.Url);
     UpdateOptions options = new UpdateOptions();
     options.IsUpsert = true;
     collection.ReplaceOne(query, doc, options);
 }
コード例 #4
0
        /// <summary>
        /// อัพเดทข้อมูล Class room
        /// </summary>
        /// <param name="data">ข้อมูลที่จะทำการอัพเดท</param>
        public void UpsertClassRoom(ClassRoom data)
        {
            var update = Builders<ClassRoom>.Update
             .Set(it => it.Name, data.Name)
             .Set(it => it.CourseCatalogId, data.CourseCatalogId)
             .Set(it => it.DeletedDate, data.DeletedDate)
             .Set(it => it.Message, data.Message)
             .Set(it => it.Lessons, data.Lessons)
             .Set(it => it.LastUpdatedMessageDate, data.LastUpdatedMessageDate);

            var updateOption = new UpdateOptions { IsUpsert = true };
            MongoAccess.MongoUtil.Instance.GetCollection<ClassRoom>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #5
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูล Student key
        /// </summary>
        /// <param name="data">ข้อมูลที่ต้องการดำเนินการ</param>
        public void UpsertStudentKey(StudentKey data)
        {
            var update = Builders<StudentKey>.Update
               .Set(it => it.Code, data.Code)
               .Set(it => it.Grade, data.Grade)
               .Set(it => it.CourseCatalogId, data.CourseCatalogId)
               .Set(it => it.ClassRoomId, data.ClassRoomId)
               .Set(it => it.CreatedDate, data.CreatedDate)
               .Set(it => it.DeletedDate, data.DeletedDate);

            var updateOption = new UpdateOptions { IsUpsert = true };
            MongoAccess.MongoUtil.Instance.GetCollection<StudentKey>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #6
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูลการขอเป็นเพื่อน
        /// </summary>
        /// <param name="data">ข้อมูลที่ต้องการดำเนินการ</param>
        public void UpsertFriendRequest(FriendRequest data)
        {
            var update = Builders<FriendRequest>.Update
             .Set(it => it.FromUserProfileId, data.FromUserProfileId)
             .Set(it => it.ToUserProfileId, data.ToUserProfileId)
             .Set(it => it.Status, data.Status)
             .Set(it => it.AcceptedDate, data.AcceptedDate)
             .Set(it => it.CreatedDate, data.CreatedDate)
             .Set(it => it.DeletedDate, data.DeletedDate);

            var updateOption = new UpdateOptions { IsUpsert = true };
            MongoAccess.MongoUtil.Instance.GetCollection<FriendRequest>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #7
0
 public MongoDbUpdateOperation(CommandActivator activator,
                               IMongoDatabase database,
                               string collectionName,
                               Func <Row, MongoDB.Driver.FilterDefinition <T> > filter,
                               Func <Row, MongoDB.Driver.UpdateDefinition <T> > update,
                               MongoDB.Driver.UpdateOptions options = null)
 {
     _activator          = activator;
     this.database       = database;
     this.collectionName = collectionName;
     this.filter         = filter;
     this.update         = update;
     this.options        = options;
 }
コード例 #8
0
        /// <summary>
        /// แก้ไขหรือเพิ่มข้อมูล Like lesson
        /// </summary>
        /// <param name="data">ข้อมูลที่จะทำการอัพเดทหรือเพิ่ม</param>
        public void UpsertLikeLesson(LikeLesson data)
        {
            var update = Builders<LikeLesson>.Update
               .Set(it => it.ClassRoomId, data.ClassRoomId)
               .Set(it => it.LessonId, data.LessonId)
               .Set(it => it.LikedByUserProfileId, data.LikedByUserProfileId)
               .Set(it => it.LastNotifyRequest, data.LastNotifyRequest)
               .Set(it => it.LastNotifyComplete, data.LastNotifyComplete)
               .Set(it => it.CreatedDate, data.CreatedDate)
               .Set(it => it.DeletedDate, data.DeletedDate);

            var updateOption = new UpdateOptions { IsUpsert = true };
            MongoAccess.MongoUtil.Instance.GetCollection<LikeLesson>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #9
0
 public async Task Get(string id)
 {
     var options = new UpdateOptions { IsUpsert = true };
         for (;;)
         {
             var biscInput = BiscParser.Parse(id);
             var iscInput = IscParser.Parse(id);
             var biscFilter = Builders<Month>.Filter.Eq(m => m.YearMonth, biscInput.YearMonth);
             var iscFilter = Builders<Month>.Filter.Eq(m => m.YearMonth, iscInput.YearMonth);
             if ((biscInput.Percent == "до грудня \r\n\t\tпопереднього року") || (iscInput.Percent == "&nbsp;")) break;
             await collectionIsc.ReplaceOneAsync(iscFilter, iscInput, options);
             await сollectionBisc.ReplaceOneAsync(biscFilter, biscInput, options);             //insert and update date in DB
         }
     IscParser.parseLineNumber = 2;
     BiscParser.parseLineNumber = 3;
 }
コード例 #10
0
        public void UpdateMany <T>(IMongoCollection <T> collection, string filter, string update)
        {
            try
            {
                MongoDB.Driver.UpdateOptions updateOptions;

                updateOptions          = new MongoDB.Driver.UpdateOptions();
                updateOptions.IsUpsert = false;

                collection.UpdateMany(filter, update, updateOptions);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
コード例 #11
0
        /// <summary>
        /// อัพเดทข้อมูล Class room
        /// </summary>
        /// <param name="data">ข้อมูลที่จะทำการอัพเดท</param>
        public async Task UpsertClassRoom(ClassRoom data)
        {
            var update = Builders<ClassRoom>.Update
             .Set(it => it.Name, data.Name)
             .Set(it => it.CourseCatalogId, data.CourseCatalogId)
             .Set(it => it.CreatedDate, data.CreatedDate)
             .Set(it => it.DeletedDate, data.DeletedDate)
             .Set(it => it.Message, data.Message)
             .Set(it => it.IsPublic, data.IsPublic)
             .Set(it => it.Lessons, data.Lessons)
             .Set(it => it.LastUpdatedMessageDate, data.LastUpdatedMessageDate);

            var updateOption = new UpdateOptions { IsUpsert = true };
            await MongoAccess.MongoUtil.Instance.GetCollection<ClassRoom>(AppConfigOptions.ClassRoomTableName)
               .UpdateOneAsync(it => it.id == data.id, update, updateOption);
        }
コード例 #12
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูลกิจกรรม
        /// </summary>
        /// <param name="data">ข้อมูลกิจกรรมที่ต้องการดำเนินการ</param>
        public void UpsertUserActivity(UserActivity data)
        {
            var update = Builders<UserActivity>.Update
              .Set(it => it.IsTeacher, data.IsTeacher)
              .Set(it => it.IsPrivateAccount, data.IsPrivateAccount)
              .Set(it => it.UserProfileName, data.UserProfileName)
              .Set(it => it.UserProfileImageUrl, data.UserProfileImageUrl)
              .Set(it => it.HideClassRoomMessageDate, data.HideClassRoomMessageDate)
              .Set(it => it.UserProfileId, data.UserProfileId)
              .Set(it => it.ClassRoomId, data.ClassRoomId)
              .Set(it => it.CreatedDate, data.CreatedDate)
              .Set(it => it.DeletedDate, data.DeletedDate)
              .Set(it => it.LessonActivities, data.LessonActivities);

            var updateOption = new UpdateOptions { IsUpsert = true };
            _mongoUtil.GetCollection<UserActivity>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #13
0
        public async Task UpsertTestedResult(LessonTestResult data)
        {
            var isNewRecord = string.IsNullOrEmpty(data.id);
            if (isNewRecord)
            {
                data.id = Guid.NewGuid().ToString();
                data.CreatedDate = DateTime.Now;
                await _mongoUtil.GetCollection<LessonTestResult>(TableName).InsertOneAsync(data);
            }
            else
            {
                var update = Builders<LessonTestResult>.Update
                 .Set(it => it.Answers, data.Answers);

                var updateOption = new UpdateOptions { IsUpsert = true };
                _mongoUtil.GetCollection<LessonTestResult>(TableName)
                   .UpdateOne(it => it.id == data.id, update, updateOption);
            }
        }
コード例 #14
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูล notification
        /// </summary>
        /// <param name="data">ข้อมูลที่ต้องการดำเนินการ</param>
        public void Upsert(Notification data)
        {
            var update = Builders<Notification>.Update
               .Set(it => it.LastReadedDate, data.LastReadedDate)
               .Set(it => it.LastUpdateDate, data.LastUpdateDate)
               .Set(it => it.ToUserProfileId, data.ToUserProfileId)
               .Set(it => it.ClassRoomId, data.ClassRoomId)
               .Set(it => it.LessonId, data.LessonId)
               .Set(it => it.CreatedDate, data.CreatedDate)
               .Set(it => it.HideDate, data.HideDate)
               .Set(it => it.Message, data.Message)
               .Set(it => it.ByUserProfileId, data.ByUserProfileId)
               .Set(it => it.TotalLikes, data.TotalLikes)
               .Set(it => it.Tag, data.Tag);

            var updateOption = new UpdateOptions { IsUpsert = true };
            _mongoUtil.GetCollection<Notification>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #15
0
        public void UpdateMany <T>(string collectionName, string filter, string update)
        {
            try
            {
                MongoDB.Driver.UpdateOptions updateOptions;

                updateOptions          = new MongoDB.Driver.UpdateOptions();
                updateOptions.IsUpsert = false;

                var database = MongoUtils.CreateMongoDB(_mongoDBConnectionStr, _dataBaseName);

                var collection = database.GetCollection <T>(collectionName);

                collection.UpdateMany(filter, update, updateOptions);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
コード例 #16
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูล Class calendar
        /// </summary>
        /// <param name="data">ข้อมูลที่ต้องการดำเนินการ</param>
        public void UpsertClassCalendar(ClassCalendar data)
        {
            var update = Builders<ClassCalendar>.Update
             .Set(it => it.BeginDate, data.BeginDate)
             .Set(it => it.IsWeekendHoliday, data.IsWeekendHoliday)
             .Set(it => it.ExpiredDate, data.ExpiredDate)
             .Set(it => it.CloseDate, data.CloseDate)
             .Set(it => it.ClassRoomId, data.ClassRoomId)
             .Set(it => it.LastCalculateHolidayRequest, data.LastCalculateHolidayRequest)
             .Set(it => it.LastCalculateHolidayComplete, data.LastCalculateHolidayComplete)
             .Set(it => it.CreatedDate, data.CreatedDate)
             .Set(it => it.DeletedDate, data.DeletedDate)
             .Set(it => it.LessonCalendars, data.LessonCalendars)
             .Set(it => it.Holidays, data.Holidays)
             .Set(it => it.ShiftDays, data.ShiftDays);

            var updateOption = new UpdateOptions { IsUpsert = true };
            MongoAccess.MongoUtil.Instance.GetCollection<ClassCalendar>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #17
0
        /// <summary>
        /// เพิ่มหรืออัพเดทข้อมูล comment
        /// </summary>
        /// <param name="data">ข้อมูล comment ที่จะดำเนินการ</param>
        public void UpsertComment(Comment data)
        {
            var update = Builders<Comment>.Update
             .Set(it => it.Description, data.Description)
             .Set(it => it.TotalLikes, data.TotalLikes)
             .Set(it => it.CreatorImageUrl, data.CreatorImageUrl)
             .Set(it => it.CreatorDisplayName, data.CreatorDisplayName)
             .Set(it => it.ClassRoomId, data.ClassRoomId)
             .Set(it => it.LessonId, data.LessonId)
             .Set(it => it.CreatedByUserProfileId, data.CreatedByUserProfileId)
             .Set(it => it.LastNotifyRequest, data.LastNotifyRequest)
             .Set(it => it.LastNotifyComplete, data.LastNotifyComplete)
             .Set(it => it.CreatedDate, data.CreatedDate)
             .Set(it => it.DeletedDate, data.DeletedDate)
             .Set(it => it.Discussions, data.Discussions);

            var updateOption = new UpdateOptions { IsUpsert = true };
            MongoAccess.MongoUtil.Instance.GetCollection<Comment>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #18
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูล lesson catalog
        /// </summary>
        /// <param name="lessonCatalogId">ข้อมูลที่ต้องการดำเนินการ</param>
        public async Task UpsertLessonCatalog(LessonCatalog data)
        {
            var update = Builders<LessonCatalog>.Update
              .Set(it => it.Order, data.Order)
              .Set(it => it.Title, data.Title)
              .Set(it => it.UnitNo, data.UnitNo)
              .Set(it => it.SemesterName, data.SemesterName)
              .Set(it => it.CourseCatalogId, data.CourseCatalogId)
              .Set(it => it.CreatedDate, data.CreatedDate)
              .Set(it => it.DeletedDate, data.DeletedDate)
              .Set(it => it.Advertisments, data.Advertisments)
              .Set(it => it.TopicOfTheDays, data.TopicOfTheDays)
              .Set(it => it.TeacherItems, data.TeacherItems)
              .Set(it => it.StudentItems, data.StudentItems)
              .Set(it => it.PreAssessments, data.PreAssessments)
              .Set(it => it.PostAssessments, data.PostAssessments);

            var updateOption = new UpdateOptions { IsUpsert = true };
            await MongoAccess.MongoUtil.Instance
                .GetCollection<LessonCatalog>(AppConfigOptions.LessonCatalogTableName)
               .UpdateOneAsync(it => it.id == data.id, update, updateOption);
        }
コード例 #19
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูล course catalog
        /// </summary>
        /// <param name="data">ข้อมูลที่ต้องการดำเนินการ</param>
        public async Task UpsertCourseCatalog(CourseCatalog data)
        {
            var update = Builders<CourseCatalog>.Update
               .Set(it => it.GroupName, data.GroupName)
               .Set(it => it.Advertisements, data.Advertisements)
               .Set(it => it.Grade, data.Grade)
               .Set(it => it.SideName, data.SideName)
               .Set(it => it.PriceUSD, data.PriceUSD)
               .Set(it => it.Series, data.Series)
               .Set(it => it.Title, data.Title)
               .Set(it => it.FullDescription, data.FullDescription)
               .Set(it => it.DescriptionImageUrl, data.DescriptionImageUrl)
               .Set(it => it.CreatedDate, data.CreatedDate)
               .Set(it => it.DeletedDate, data.DeletedDate)
               .Set(it => it.Semesters, data.Semesters)
               .Set(it => it.IsFree, data.IsFree)
               .Set(it => it.TotalWeeks, data.TotalWeeks);

            var updateOption = new UpdateOptions { IsUpsert = true };
            await MongoAccess.MongoUtil.Instance
                .GetCollection<CourseCatalog>(AppConfigOptions.CourseCatalogTableName)
               .UpdateOneAsync(it => it.id == data.id, update, updateOption);
        }
コード例 #20
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูล contract
        /// </summary>
        /// <param name="data">ข้อมูลที่ต้องการดำเนินการ</param>
        public async Task UpsertContract(Contract data)
        {
            var update = Builders<Contract>.Update
             .Set(it => it.SchoolName, data.SchoolName)
             .Set(it => it.City, data.City)
             .Set(it => it.State, data.State)
             .Set(it => it.ZipCode, data.ZipCode)
             .Set(it => it.PrimaryContractName, data.PrimaryContractName)
             .Set(it => it.PrimaryPhoneNumber, data.PrimaryPhoneNumber)
             .Set(it => it.PrimaryEmail, data.PrimaryEmail)
             .Set(it => it.SecondaryContractName, data.SecondaryContractName)
             .Set(it => it.SecondaryPhoneNumber, data.SecondaryPhoneNumber)
             .Set(it => it.SecondaryEmail, data.SecondaryEmail)
             .Set(it => it.StartDate, data.StartDate)
             .Set(it => it.ExpiredDate, data.ExpiredDate)
             .Set(it => it.TimeZone, data.TimeZone)
             .Set(it => it.CreatedDate, data.CreatedDate)
             .Set(it => it.DeletedDate, data.DeletedDate)
             .Set(it => it.Licenses, data.Licenses);

            var updateOption = new UpdateOptions { IsUpsert = true };
            await MongoAccess.MongoUtil.Instance.GetCollection<Contract>(AppConfigOptions.ContractTableName)
               .UpdateOneAsync(it => it.id == data.id, update, updateOption);
        }
コード例 #21
0
        /// <summary>
        /// Replaces a single document.
        /// </summary>
        /// <typeparam name="TDocument">The type of the document.</typeparam>
        /// <param name="collection">The collection.</param>
        /// <param name="filter">The filter.</param>
        /// <param name="replacement">The replacement.</param>
        /// <param name="options">The options.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// The result of the replacement.
        /// </returns>
        public static Task <ReplaceOneResult> ReplaceOneAsync <TDocument>(this IMongoCollection <TDocument> collection, Expression <Func <TDocument, bool> > filter, TDocument replacement, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(collection, "collection");
            Ensure.IsNotNull(filter, "filter");

            return(collection.ReplaceOneAsync(new ExpressionFilterDefinition <TDocument>(filter), replacement, options, cancellationToken));
        }
コード例 #22
0
        /// <summary>
        /// Renew the expiration of a lock with the specified <paramref name="name" /> and <paramref name="expiration" />.
        /// </summary>
        /// <param name="name">The name of the lock.</param>
        /// <param name="expiration">The amount of time before the lock will expire and be free to be acquired again.</param>
        /// <returns></returns>
        public virtual void Renew(string name, TimeSpan expiration)
        {
            if (name == null)
                throw new ArgumentNullException(nameof(name));

            var builder = Builders<LockData>.Filter;
            var filter = builder.Eq(m => m.Id, name);

            var update = Builders<LockData>.Update
                .Set(p => p.Updated, DateTime.UtcNow)
                .Set(p => p.Expire, DateTime.UtcNow.Add(expiration));

            var options = new UpdateOptions { IsUpsert = false };

            Collection.UpdateOneAsync(filter, update, options).Wait();
        }
コード例 #23
0
 /// <inheritdoc />
 public virtual UpdateResult UpdateOne(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(UpdateOne(filter, update, options, (requests, bulkWriteOptions) => BulkWrite(requests, bulkWriteOptions, cancellationToken)));
 }
コード例 #24
0
 public void SaveAccessKey(AccessKey accessKey, TObjectState state)
 {
     IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
     IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("AccessKey");
     FilterDefinition<BsonDocument> query = Builders<BsonDocument>.Filter.Eq("_id", accessKey.Key);
     if ((state == TObjectState.Add) || (state == TObjectState.Update))
     {
         BsonDocument doc = new BsonDocument();
         BsonHelper.SetValue(doc, "_id", accessKey.Key);
         BsonHelper.SetValue(doc, "OrganisationID", accessKey.OrganisationID);
         BsonHelper.SetValue(doc, "Name", accessKey.Name);
         BsonHelper.SetValue(doc, "Secret", accessKey.Secret);
         UpdateOptions options = new UpdateOptions();
         options.IsUpsert = true;
         collection.ReplaceOne(query, doc, options);
     }
     else if (state == TObjectState.Delete)
     {
         collection.DeleteOne(query);
     }
     BroadcastTableChange("AccessKey", accessKey.Key);
 }
コード例 #25
0
        private static void Upsert(IMongoCollection<BsonDocument> collection, BsonDocument newDoc, FilterDefinition<BsonDocument> filter)
        {
            var options = new UpdateOptions();
            options.IsUpsert = true;

            collection.ReplaceOneAsync(filter, newDoc, options).Wait();
        }
コード例 #26
0
        /// <inheritdoc />
        public virtual ReplaceOneResult ReplaceOne(FilterDefinition <TDocument> filter, TDocument replacement, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(filter, nameof(filter));
            Ensure.IsNotNull((object)replacement, "replacement");

            options = options ?? new UpdateOptions();
            var model = new ReplaceOneModel <TDocument>(filter, replacement)
            {
                IsUpsert = options.IsUpsert
            };

            try
            {
                var bulkWriteOptions = new BulkWriteOptions
                {
                    BypassDocumentValidation = options.BypassDocumentValidation
                };
                var result = BulkWrite(new[] { model }, bulkWriteOptions, cancellationToken);
                return(ReplaceOneResult.FromCore(result));
            }
            catch (MongoBulkWriteException <TDocument> ex)
            {
                throw MongoWriteException.FromBulkWriteException(ex);
            }
        }
コード例 #27
0
        /// <inheritdoc />
        public virtual async Task <ReplaceOneResult> ReplaceOneAsync(FilterDefinition <TDocument> filter, TDocument replacement, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(filter, "filter");
            Ensure.IsNotNull((object)replacement, "replacement");

            options = options ?? new UpdateOptions();
            var model = new ReplaceOneModel <TDocument>(filter, replacement)
            {
                IsUpsert = options.IsUpsert
            };

            try
            {
                var result = await BulkWriteAsync(new[] { model }, null, cancellationToken).ConfigureAwait(false);

                return(ReplaceOneResult.FromCore(result));
            }
            catch (MongoBulkWriteException <TDocument> ex)
            {
                throw MongoWriteException.FromBulkWriteException(ex);
            }
        }
コード例 #28
0
 public virtual ReplaceOneResult ReplaceOne(FilterDefinition <TDocument> filter, TDocument replacement, UpdateOptions options, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(ReplaceOne(filter, replacement, ReplaceOptions.From(options), (requests, bulkWriteOptions) => BulkWrite(requests, bulkWriteOptions, cancellationToken)));
 }
コード例 #29
0
        /// <summary>
        /// Save the specified <paramref name="message" /> as an asynchronous operation.
        /// </summary>
        /// <param name="message">The message to save.</param>
        /// <returns>
        /// The <see cref="Task" /> representing the asynchronous operation.
        /// </returns>
        /// <exception cref="ArgumentNullException"><paramref name="message"/> is <see langword="null" />.</exception>
        public Task<Message> Save(Message message)
        {
            if (message == null)
                throw new ArgumentNullException("message");

            // generate id if null, upsert requires id
            if (string.IsNullOrEmpty(message.Id))
            {
                message.Id = ObjectId.GenerateNewId().ToString();
                message.Created = DateTime.UtcNow;
            }

            message.Updated = DateTime.UtcNow;

            var updateOptions = new UpdateOptions { IsUpsert = true };

            return _collection
                .ReplaceOneAsync(m => m.Id == message.Id, message, updateOptions)
                .ContinueWith(t => message);
        }
コード例 #30
0
        private UpdateResult UpdateMany(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options, Func <IEnumerable <WriteModel <TDocument> >, BulkWriteOptions, BulkWriteResult <TDocument> > bulkWrite)
        {
            Ensure.IsNotNull(filter, nameof(filter));
            Ensure.IsNotNull(update, nameof(update));

            options = options ?? new UpdateOptions();
            var model = new UpdateManyModel <TDocument>(filter, update)
            {
                ArrayFilters = options.ArrayFilters,
                Collation    = options.Collation,
                IsUpsert     = options.IsUpsert
            };

            try
            {
                var bulkWriteOptions = new BulkWriteOptions
                {
                    BypassDocumentValidation = options.BypassDocumentValidation
                };
                var result = bulkWrite(new[] { model }, bulkWriteOptions);
                return(UpdateResult.FromCore(result));
            }
            catch (MongoBulkWriteException <TDocument> ex)
            {
                throw MongoWriteException.FromBulkWriteException(ex);
            }
        }
コード例 #31
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูล Class calendar
        /// </summary>
        /// <param name="data">ข้อมูลที่ต้องการดำเนินการ</param>
        public void UpsertClassCalendar(ClassCalendar data)
        {
            var update = Builders<ClassCalendar>.Update
             .Set(it => it.BeginDate, data.BeginDate)
             .Set(it => it.ExpiredDate, data.ExpiredDate)
             .Set(it => it.CloseDate, data.CloseDate)
             .Set(it => it.ClassRoomId, data.ClassRoomId)
             .Set(it => it.CreatedDate, data.CreatedDate)
             .Set(it => it.DeletedDate, data.DeletedDate)
             .Set(it => it.LessonCalendars, data.LessonCalendars)
             .Set(it => it.Holidays, data.Holidays)
             .Set(it => it.ShiftDays, data.ShiftDays);

            var updateOption = new UpdateOptions { IsUpsert = true };
            _mongoUtil.GetCollection<ClassCalendar>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #32
0
 public void SaveObjectDefinitions(List<ObjectDefinition> items, TObjectState state)
 {
     IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
     IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("ObjectDefinition");
     foreach (ObjectDefinition item in items)
     {
         if (item.ObjectDefinitionID == Guid.Empty)
             item.ObjectDefinitionID = Guid.NewGuid();
         FilterDefinition<BsonDocument> query = Builders<BsonDocument>.Filter.Eq("_id", item.ObjectDefinitionID.ToByteArray());
         if ((state == TObjectState.Add) || (state == TObjectState.Update))
         {
             BsonDocument doc = new BsonDocument();
             BsonHelper.SetValue(doc, "_id", item.ObjectDefinitionID);
             BsonHelper.SetValue(doc, "ObjectID", item.ObjectID);
             if (item.OrganisationID.HasValue && (item.OrganisationID.Value == 0))
                 item.OrganisationID = null;
             BsonHelper.SetValue(doc, "OrganisationID", item.OrganisationID);
             BsonHelper.SetValue(doc, "Name", item.Name);
             BsonHelper.SetValue(doc, "MIMEType", item.MIMEType);
             BsonHelper.SetValue(doc, "SerialisationName", item.SerialisationName);
             BsonHelper.SetValue(doc, "Description", item.Description);
             BsonHelper.SetValue(doc, "Singleton", item.Singleton);
             if ((item.Properties != null) && item.Properties.Count > 0)
             {
                 BsonArray array = new BsonArray();
                 foreach (PropertyDefinition property in item.Properties)
                 {
                     if (property.PropertyDefinitionID == Guid.Empty)
                         property.PropertyDefinitionID = Guid.NewGuid();
                     BsonDocument propertyDoc = new BsonDocument();
                     BsonHelper.SetValue(propertyDoc, "_id", property.PropertyDefinitionID);
                     BsonHelper.SetValue(propertyDoc, "PropertyID", property.PropertyID);
                     BsonHelper.SetValue(propertyDoc, "Name", property.Name);
                     BsonHelper.SetValue(propertyDoc, "Description", property.Description);
                     BsonHelper.SetValue(propertyDoc, "DataType", (int)property.DataType);
                     BsonHelper.SetValue(propertyDoc, "DataTypeLength", property.DataTypeLength);
                     BsonHelper.SetValue(propertyDoc, "MIMEType", property.MIMEType);
                     BsonHelper.SetValue(propertyDoc, "MinValue", property.MinValue);
                     BsonHelper.SetValue(propertyDoc, "MaxValue", property.MaxValue);
                     BsonHelper.SetValue(propertyDoc, "Units", property.Units);
                     BsonHelper.SetValue(propertyDoc, "IsCollection", property.IsCollection);
                     BsonHelper.SetValue(propertyDoc, "IsMandatory", property.IsMandatory);
                     BsonHelper.SetValue(propertyDoc, "Access", (int)property.Access);
                     BsonHelper.SetValue(propertyDoc, "SortOrder", property.SortOrder);
                     BsonHelper.SetValue(propertyDoc, "SerialisationName", property.SerialisationName);
                     BsonHelper.SetValue(propertyDoc, "CollectionItemSerialisationName", property.CollectionItemSerialisationName);
                     array.Add(propertyDoc);
                 }
                 doc.Add("Properties", array);
             }
             UpdateOptions options = new UpdateOptions();
             options.IsUpsert = true;
             collection.ReplaceOne(query, doc, options);
         }
         else if (state == TObjectState.Delete)
         {
             collection.DeleteOne(query);
         }
     }
     BroadcastTableChange("ObjectDefinition", string.Empty);
 }
コード例 #33
0
        private async Task <UpdateResult> UpdateOneAsync(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options, Func <IEnumerable <WriteModel <TDocument> >, BulkWriteOptions, Task <BulkWriteResult <TDocument> > > bulkWriteAsync)
        {
            Ensure.IsNotNull(filter, nameof(filter));
            Ensure.IsNotNull(update, nameof(update));

            options = options ?? new UpdateOptions();
            var model = new UpdateOneModel <TDocument>(filter, update)
            {
                ArrayFilters = options.ArrayFilters,
                Collation    = options.Collation,
                Hint         = options.Hint,
                IsUpsert     = options.IsUpsert
            };

            try
            {
                var bulkWriteOptions = new BulkWriteOptions
                {
                    BypassDocumentValidation = options.BypassDocumentValidation
                };
                var result = await bulkWriteAsync(new[] { model }, bulkWriteOptions).ConfigureAwait(false);

                return(UpdateResult.FromCore(result));
            }
            catch (MongoBulkWriteException <TDocument> ex)
            {
                throw MongoWriteException.FromBulkWriteException(ex);
            }
        }
コード例 #34
0
 /// <inheritdoc />
 public virtual Task <UpdateResult> UpdateOneAsync(IClientSessionHandle session, FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(UpdateOneAsync(filter, update, options, (requests, bulkWriteOptions) => BulkWriteAsync(session, requests, bulkWriteOptions, cancellationToken)));
 }
コード例 #35
0
        /// <inheritdoc />
        public virtual async Task <UpdateResult> UpdateOneAsync(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(filter, nameof(filter));
            Ensure.IsNotNull(update, nameof(update));

            options = options ?? new UpdateOptions();
            var model = new UpdateOneModel <TDocument>(filter, update)
            {
                IsUpsert = options.IsUpsert
            };

            try
            {
                var bulkWriteOptions = new BulkWriteOptions
                {
                    BypassDocumentValidation = options.BypassDocumentValidation
                };
                var result = await BulkWriteAsync(new[] { model }, bulkWriteOptions, cancellationToken).ConfigureAwait(false);

                return(UpdateResult.FromCore(result));
            }
            catch (MongoBulkWriteException <TDocument> ex)
            {
                throw MongoWriteException.FromBulkWriteException(ex);
            }
        }
コード例 #36
0
        private async Task <ReplaceOneResult> ReplaceOneAsync(FilterDefinition <TDocument> filter, TDocument replacement, UpdateOptions options, Func <IEnumerable <WriteModel <TDocument> >, BulkWriteOptions, Task <BulkWriteResult <TDocument> > > bulkWriteAsync)
        {
            Ensure.IsNotNull(filter, nameof(filter));
            Ensure.IsNotNull((object)replacement, "replacement");
            if (options?.ArrayFilters != null)
            {
                throw new ArgumentException("ArrayFilters cannot be used with ReplaceOne.", nameof(options));
            }

            options = options ?? new UpdateOptions();
            var model = new ReplaceOneModel <TDocument>(filter, replacement)
            {
                Collation = options.Collation,
                IsUpsert  = options.IsUpsert
            };

            try
            {
                var bulkWriteOptions = new BulkWriteOptions
                {
                    BypassDocumentValidation = options.BypassDocumentValidation
                };
                var result = await bulkWriteAsync(new[] { model }, bulkWriteOptions).ConfigureAwait(false);

                return(ReplaceOneResult.FromCore(result));
            }
            catch (MongoBulkWriteException <TDocument> ex)
            {
                throw MongoWriteException.FromBulkWriteException(ex);
            }
        }
コード例 #37
0
        /// <summary>
        /// Release a lock with the specified <paramref name="name"/>.  Note, release is typically not used on a throttle lock.
        /// </summary>
        /// <param name="name">The name of the lock.</param>
        public override void Release(string name)
        {
            if (name == null)
                throw new ArgumentNullException(nameof(name));

            var builder = Builders<LockData>.Filter;
            var filter = builder.Eq(m => m.Id, name);

            var update = Builders<LockData>.Update
                .Set(p => p.IsLocked, false)
                .Set(p => p.Updated, DateTime.UtcNow)
                .Unset(p => p.Expire);

            var options = new UpdateOptions { IsUpsert = false };

            Collection.UpdateOneAsync(filter, update, options).Wait();
        }
コード例 #38
0
 public void SaveBootstrapServer(BootstrapServer bootstrapServer, TObjectState state)
 {
     IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
     IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("BootstrapServer");
     FilterDefinition<BsonDocument> query = Builders<BsonDocument>.Filter.Eq("_id", bootstrapServer.Url);
     if ((state == TObjectState.Add) || (state == TObjectState.Update))
     {
         BsonDocument doc = new BsonDocument();
         BsonHelper.SetValue(doc, "_id", bootstrapServer.Url);
         if (bootstrapServer.ServerIdentities != null && bootstrapServer.ServerIdentities.Count > 0)
         {
             BsonArray array = new BsonArray();
             foreach (PSKIdentity pskIdentity in bootstrapServer.ServerIdentities)
             {
                 BsonDocument pskIdentityDoc = new BsonDocument();
                 BsonHelper.SetValue(pskIdentityDoc, "_id", pskIdentity.Identity);
                 BsonHelper.SetValue(pskIdentityDoc, "Secret", pskIdentity.Secret);
                 array.Add(pskIdentityDoc);
             }
             doc.Add("ServerIdentities", array);
         }
         if (bootstrapServer.ServerCertificate != null)
         {
             BsonDocument serverCertificateDoc = new BsonDocument();
             BsonHelper.SetValue(serverCertificateDoc, "_id", (int)bootstrapServer.ServerCertificate.CertificateFormat);
             BsonHelper.SetValue(serverCertificateDoc, "RawCertificate", bootstrapServer.ServerCertificate.RawCertificate);
             doc.Add("ServerCertificate", serverCertificateDoc);
         }
         UpdateOptions options = new UpdateOptions();
         options.IsUpsert = true;
         collection.ReplaceOne(query, doc, options);
     }
     else if (state == TObjectState.Delete)
     {
         collection.DeleteOne(query);
     }
     BroadcastTableChange("BootstrapServer", string.Empty);
 }
コード例 #39
0
        public void SaveSubscription(Subscription subscription, TObjectState state)
        {
            IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
            IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>(COLLECTION_NAME);
            EnsureIndexExists<BsonDocument>(collection, "OrganisationID");
            EnsureIndexExists<BsonDocument>(collection, "ClientID");

            FilterDefinition<BsonDocument> query = Builders<BsonDocument>.Filter.Eq("_id", subscription.SubscriptionID.ToByteArray());
            if ((state == TObjectState.Add) || (state == TObjectState.Update))
            {
                BsonDocument doc = new BsonDocument();
                BsonHelper.SetValue(doc, "_id", subscription.SubscriptionID);
                BsonHelper.SetValue(doc, "OrganisationID", subscription.OrganisationID);

                BsonHelper.SetValue(doc, "ClientID", subscription.ClientID);
                BsonHelper.SetValue(doc, "DefinitionID", subscription.ObjectDefinitionID);
                BsonHelper.SetValue(doc, "ObjectID", subscription.ObjectID);

                BsonHelper.SetValue(doc, "SubscriptionType", (int)subscription.SubscriptionType);
                BsonHelper.SetValue(doc, "PropertyDefinitionID", subscription.PropertyDefinitionID);
                BsonHelper.SetValue(doc, "Url", subscription.Url);
                BsonHelper.SetValue(doc, "AcceptContentType", subscription.AcceptContentType);

                if (subscription.NotificationParameters != null)
                {
                    MemoryStream stream = new MemoryStream();
                    subscription.NotificationParameters.Serialise(stream);
                    BsonHelper.SetValue(doc, "NotificationParameters", StringUtils.Encode(stream.ToArray()));
                }

                UpdateOptions options = new UpdateOptions();
                options.IsUpsert = true;
                collection.ReplaceOne(query, doc, options);
            }
            else if (state == TObjectState.Delete)
            {
                collection.DeleteOne(query);
            }
            BroadcastTableChange(COLLECTION_NAME, StringUtils.GuidEncode(subscription.SubscriptionID));
        }
コード例 #40
0
 /// <inheritdoc />
 public virtual Task <ReplaceOneResult> ReplaceOneAsync(FilterDefinition <TDocument> filter, TDocument replacement, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(ReplaceOneAsync(filter, replacement, options, (requests, bulkWriteOptions) => BulkWriteAsync(requests, bulkWriteOptions, cancellationToken)));
 }
コード例 #41
0
        private void CheckSchedule()
        {
            var watch = Stopwatch.StartNew();
            
            var currentDate = DateTime.UtcNow;

            // all message that are scheduled and schedule date before now
            Expression<Func<Message, bool>> filter = m => m.State == MessageState.Scheduled && m.Scheduled < currentDate;

            // update all messages to queued
            var updateDefinition = Builders<Message>.Update
                .Set(m => m.State, MessageState.Queued)
                .Set(p => p.Updated, DateTime.UtcNow);

            var updateOptions = new UpdateOptions { IsUpsert = false };

            var t = Repository.Collection.UpdateManyAsync(
                filter,
                updateDefinition,
                updateOptions);

            // wait for result
            var result = t.Result;

            watch.Stop();

            // log as Info if there are results
            Logger.Info()
                .Message("Completed '{0}' schedule check in: {1} ms. Schedule Message Count: {2}", Name, watch.ElapsedMilliseconds, result.ModifiedCount)
                .WriteIf(result.ModifiedCount > 0);

        }
コード例 #42
0
        /// <summary>
        /// Updates a single document.
        /// </summary>
        /// <typeparam name="TDocument">The type of the document.</typeparam>
        /// <param name="collection">The collection.</param>
        /// <param name="filter">The filter.</param>
        /// <param name="update">The update.</param>
        /// <param name="options">The options.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// The result of the update operation.
        /// </returns>
        public static Task <UpdateResult> UpdateOneAsync <TDocument>(this IMongoCollection <TDocument> collection, Expression <Func <TDocument, bool> > filter, object update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(collection, "collection");
            Ensure.IsNotNull(filter, "filter");

            return(collection.UpdateOneAsync(filter, update, options, cancellationToken));
        }
コード例 #43
0
        /// <inheritdoc />
        public virtual UpdateResult UpdateOne(FilterDefinition <TDocument> filter, UpdateDefinition <TDocument> update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(filter, nameof(filter));
            Ensure.IsNotNull(update, nameof(update));

            options = options ?? new UpdateOptions();
            var model = new UpdateOneModel <TDocument>(filter, update)
            {
                ArrayFilters = options.ArrayFilters,
                Collation    = options.Collation,
                IsUpsert     = options.IsUpsert
            };

            try
            {
                var bulkWriteOptions = new BulkWriteOptions
                {
                    BypassDocumentValidation = options.BypassDocumentValidation
                };
                var result = BulkWrite(new[] { model }, bulkWriteOptions, cancellationToken);
                return(UpdateResult.FromCore(result));
            }
            catch (MongoBulkWriteException <TDocument> ex)
            {
                throw MongoWriteException.FromBulkWriteException(ex);
            }
        }
コード例 #44
0
        /// <summary>
        /// Updates a single document.
        /// </summary>
        /// <typeparam name="TDocument">The type of the document.</typeparam>
        /// <param name="collection">The collection.</param>
        /// <param name="filter">The filter.</param>
        /// <param name="update">The update.</param>
        /// <param name="options">The options.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>
        /// The result of the update operation.
        /// </returns>
        public static Task <UpdateResult> UpdateOneAsync <TDocument>(this IMongoCollection <TDocument> collection, Expression <Func <TDocument, bool> > filter, Func <UpdateBuilder <TDocument>, UpdateBuilder <TDocument> > update, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            Ensure.IsNotNull(collection, "collection");
            Ensure.IsNotNull(filter, "filter");
            Ensure.IsNotNull(update, "update");

            var updateBuilder = new UpdateBuilder <TDocument>();
            var updateObj     = update(updateBuilder);

            return(collection.UpdateOneAsync(filter, updateObj, options, cancellationToken));
        }
コード例 #45
0
        /// <summary>
        /// Verifies the lock record exists.
        /// </summary>
        /// <param name="name">The name of the lock.</param>
        protected virtual void VerifyLock(string name)
        {
            var builder = Builders<LockData>.Filter;
            var filter = builder.Eq(m => m.Id, name);

            // only set on insert
            var update = Builders<LockData>.Update
                .SetOnInsert(p => p.Id, name)
                .SetOnInsert(p => p.IsLocked, false)
                .SetOnInsert(p => p.Created, DateTime.UtcNow)
                .SetOnInsert(p => p.Updated, DateTime.UtcNow);

            var options = new UpdateOptions { IsUpsert = true };

            Collection.UpdateOneAsync(filter, update, options).Wait();
        }
コード例 #46
0
 /// <inheritdoc />
 public virtual ReplaceOneResult ReplaceOne(IClientSessionHandle session, FilterDefinition <TDocument> filter, TDocument replacement, UpdateOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(ReplaceOne(filter, replacement, options, (requests, bulkWriteOptions) => BulkWrite(session, requests, bulkWriteOptions, cancellationToken)));
 }
コード例 #47
0
ファイル: DALMetrics.cs プロジェクト: CreatorDev/DeviceServer
        private void SaveMetric(MetricBase metric, TObjectState state, BsonValue id, string collectionName, Dictionary<string, BsonValue> values)
        {
            IMongoDatabase database = GetDatabase(DATABASE_NAME, true);
            IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>(collectionName);

            if (state == TObjectState.Add)
            {
                BsonDocument newItem = new BsonDocument();
                BsonHelper.SetValue(newItem, "Name", metric.Name);
                BsonHelper.SetValue(newItem, "Value", metric.Value);
                foreach (KeyValuePair<string, BsonValue> pair in values)
                {
                    newItem[pair.Key] = pair.Value;
                }

                FilterDefinition<BsonDocument> filter = Builders<BsonDocument>.Filter.Eq("_id", id);
                UpdateDefinition<BsonDocument> update = Builders<BsonDocument>.Update.AddToSet("Metrics", newItem);
                UpdateOptions options = new UpdateOptions();
                options.IsUpsert = true;
                collection.UpdateOne(filter, update, options);
            }
            else if (state == TObjectState.Update)
            {
                FilterDefinition<BsonDocument> clientOrOrganisationIDFilter = Builders<BsonDocument>.Filter.Eq("_id", id);
                FilterDefinition<BsonDocument> metricNameFilter = Builders<BsonDocument>.Filter.Eq("Metrics.Name", metric.Name);
                FilterDefinition<BsonDocument> filter = Builders<BsonDocument>.Filter.And(clientOrOrganisationIDFilter, metricNameFilter);
                UpdateDefinition<BsonDocument> update = Builders<BsonDocument>.Update.Set("Metrics.$.Value", metric.Value);
                collection.UpdateOne(filter, update);
            }
            else if (state == TObjectState.Delete)
            {
                FilterDefinition<BsonDocument> filter = Builders<BsonDocument>.Filter.Eq("_id", id);
                UpdateDefinition<BsonDocument> update = Builders<BsonDocument>.Update.PullFilter("Metrics", Builders<BsonDocument>.Filter.Eq("Name", metric.Name));
                collection.UpdateOne(filter, update);
            }
        }
コード例 #48
0
 public virtual Task <ReplaceOneResult> ReplaceOneAsync(IClientSessionHandle session, FilterDefinition <TDocument> filter, TDocument replacement, UpdateOptions options, CancellationToken cancellationToken = default(CancellationToken))
 {
     return(ReplaceOneAsync(filter, replacement, ReplaceOptions.From(options), (requests, bulkWriteOptions) => BulkWriteAsync(session, requests, bulkWriteOptions, cancellationToken)));
 }
コード例 #49
0
        /// <summary>
        /// อัพเดทหรือเพิ่มข้อมูลผู้ใช้
        /// </summary>
        /// <param name="data">ข้อมูลที่ต้องการดำเนินการ</param>
        public void UpsertUserProfile(UserProfile data)
        {
            var update = Builders<UserProfile>.Update
             .Set(it => it.Name, data.Name)
             .Set(it => it.SchoolName, data.SchoolName)
             .Set(it => it.ImageProfileUrl, data.ImageProfileUrl)
             .Set(it => it.IsPrivateAccount, data.IsPrivateAccount)
             .Set(it => it.IsEnableNotification, data.IsEnableNotification)
             .Set(it => it.CourseReminder, data.CourseReminder)
             .Set(it => it.CreatedDate, data.CreatedDate)
             .Set(it => it.DeletedDate, data.DeletedDate)
             .Set(it => it.Subscriptions, data.Subscriptions);

            var updateOption = new UpdateOptions { IsUpsert = true };
            _mongoUtil.GetCollection<UserProfile>(TableName)
               .UpdateOne(it => it.id == data.id, update, updateOption);
        }
コード例 #50
0
        public async Task <UpdateResult> UpdateOneAsync(object filter, object update, UpdateOptions options, CancellationToken cancellationToken)
        {
            Ensure.IsNotNull(filter, "filter");
            Ensure.IsNotNull(update, "update");

            options = options ?? new UpdateOptions();
            var model = new UpdateOneModel <TDocument>(filter, update)
            {
                IsUpsert = options.IsUpsert
            };

            try
            {
                var result = await BulkWriteAsync(new[] { model }, null, cancellationToken).ConfigureAwait(false);

                return(UpdateResult.FromCore(result));
            }
            catch (MongoBulkWriteException <TDocument> ex)
            {
                throw MongoWriteException.FromBulkWriteException(ex);
            }
        }