예제 #1
0
        /// <summary>
        /// let the followerId follow the target id
        /// </summary>
        /// <param name="targetId">target(followee) profile id</param>
        /// <param name="followerId">the follower Profile Id</param>
        public void Follow(Guid targetId, Guid followerId)
        {
            //不允许自己follow自己
            if (targetId == followerId)
            {
                throw new Exception("不允许自己follow自己");
            }
            Dictionary <string, object> queryDict = new Dictionary <string, object>();

            queryDict.Add("_id", followerId);
            QueryObject <T> query = new QueryObject <T>(EntityRepository);

            query.AppendQuery(queryDict, QueryLogic.And);
            ((MongoDBRepository <T>)EntityRepository).Update(query,
                                                             Update.AddToSet("FollowingIds", targetId));

            //increase the followee's follower count
            Dictionary <string, object> queryDict2 = new Dictionary <string, object>();

            queryDict2.Add("_id", targetId);
            QueryObject <T> query2 = new QueryObject <T>(EntityRepository);

            query2.AppendQuery(queryDict2, QueryLogic.And);

            ((MongoDBRepository <T>)EntityRepository).Update(query2,
                                                             Update.Inc("FollowerCount", 1));

            //产生用户start follow事件
            EventService.Publish("StartFollowingEvent", targetId, followerId);
        }
        public void TestAddToSetTwice()
        {
            var update   = Update.AddToSet("a", 1).AddToSet("b", 2);
            var expected = "{ \"$addToSet\" : { \"a\" : 1, \"b\" : 2 } }";

            Assert.Equal(expected, update.ToJson());
        }
        public void TestAddToSet()
        {
            var update   = Update.AddToSet("name", "abc");
            var expected = "{ \"$addToSet\" : { \"name\" : \"abc\" } }";

            Assert.Equal(expected, update.ToJson());
        }
        public void TestAddToSet_Typed()
        {
            var update = Update <Test> .AddToSet(t => t.Y, 1);

            var expected = "{ \"$addToSet\" : { \"y\" : 1 } }";

            Assert.Equal(expected, update.ToJson());
        }
예제 #5
0
 public Task CleanupAsync(Guid id)
 {
     return(Collection.UpdateManyAsync(
                Filter.And(
                    Filter.AnyEq(x => x.ReferencedIds, id),
                    Filter.AnyNe(x => x.ReferencedIdsDeleted, id)),
                Update.AddToSet(x => x.ReferencedIdsDeleted, id)));
 }
 protected Task On(ContentDeleted @event)
 {
     return(Collection.UpdateManyAsync(
                Filter.And(
                    Filter.AnyEq(x => x.ReferencedIds, @event.ContentId),
                    Filter.AnyNe(x => x.ReferencedIdsDeleted, @event.ContentId)),
                Update.AddToSet(x => x.ReferencedIdsDeleted, @event.ContentId)));
 }
예제 #7
0
        public void UpdateFor(List <string> airingIds, List <string> tasks)
        {
            var filter = Query.In("AssetId", new BsonArray(airingIds));

            foreach (var task in tasks)
            {
                _currentAirings.Update(filter, Update.AddToSet("Tasks", task), UpdateFlags.Multi);
            }
        }
예제 #8
0
        public Task AddFollowerAsync(string userId, FollowerEntity follower)
        {
            return(Task.Run(() =>
            {
                IMongoQuery query = Query <UserEntity> .EQ(entity => entity.Id, userId);
                UpdateBuilder <UserEntity> update = Update <UserEntity> .AddToSet(entity => entity.Followers, follower);

                Collection.Update(query, update);
            }));
        }
예제 #9
0
        public Task AddMembershipAsync(string userId, UserMembershipEntity membership)
        {
            return(Task.Run(() =>
            {
                IMongoQuery query = Query <UserEntity> .EQ(entity => entity.Id, userId);
                UpdateBuilder <UserEntity> update = Update <UserEntity> .AddToSet(entity => entity.Memberships, membership);

                Collection.Update(query, update);
            }));
        }
예제 #10
0
        public void AddToWatchlist(string userId, int movieId)
        {
            //var usersCollection = _database.GetCollection<ApplicationUser>("AspNetUsers");

            var query = Query <ApplicationUser> .EQ(user => user.Id, userId);

            var update = Update <ApplicationUser> .AddToSet(user => user.Watchlist, movieId);

            _usersCollection.Update(query, update);
        }
예제 #11
0
        public void Subscribe(Address client, IEnumerable <MessageType> messageTypes)
        {
            foreach (var key in GetMessageTypeKeys(messageTypes))
            {
                var query = Query <Subscription> .EQ(s => s.Id, key);

                var update = Update <Subscription> .AddToSet(s => s.Subscribers, client.ToString());

                _subscriptions.Update(query, update, UpdateFlags.Upsert);
            }
        }
예제 #12
0
 protected Task On(AssetDeleted @event, EnvelopeHeaders headers)
 {
     return(ForAppIdAsync(@event.AppId.Id, collection =>
     {
         return collection.UpdateManyAsync(
             Filter.And(
                 Filter.AnyEq(x => x.ReferencedIds, @event.AssetId),
                 Filter.AnyNe(x => x.ReferencedIdsDeleted, @event.AssetId)),
             Update.AddToSet(x => x.ReferencedIdsDeleted, @event.AssetId));
     }));
 }
예제 #13
0
        public void Store(Type messageType, string subscriberInputQueue)
        {
            var collection = database.GetCollection(collectionName);

            var criteria = Query.EQ("_id", messageType.FullName);
            var update   = Update.AddToSet("endpoints", subscriberInputQueue);

            var safeModeResult = collection.Update(criteria, update, UpdateFlags.Upsert, SafeMode.True);

            EnsureResultIsGood(safeModeResult, "Adding {0} to {1} where _id is {2}",
                               subscriberInputQueue, collectionName, messageType.FullName);
        }
예제 #14
0
        public Project AddUser(ObjectId projectId, User user)
        {
            Collection.FindAndModify(new FindAndModifyArgs
            {
                Query  = Query <Project> .Where(p => p.Id == projectId),
                Update = Update <Project> .AddToSet(p => p.Users, user)
            });
            var project = FindById(projectId);

            Sync(new SyncEventArgs <IEntity>("save", project));
            return(project);
        }
예제 #15
0
        public Team AddUser(ObjectId teamId, User user)
        {
            Collection.FindAndModify(new FindAndModifyArgs
            {
                Query  = Query <Team> .Where(t => t.Id == teamId),
                Update = Update <Team> .AddToSet(t => t.Users, user)
            });
            var team = FindById(teamId);

            Sync(new SyncEventArgs <IEntity>("save", team));
            return(team);
        }
예제 #16
0
        public void TestAddToSetEach()
        {
            var server     = Configuration.TestServer;
            var database   = Configuration.TestDatabase;
            var collection = Configuration.GetTestCollection <C>();

            collection.RemoveAll();
            var c = new C {
                InnerObjects = new List <D>()
            };

            collection.Insert(c);
            var id = c.Id;

            var query  = Query.EQ("_id", id);
            var update = Update.AddToSet("InnerObjects", 1);

            collection.Update(query, update);
            var d1 = new D {
                X = 1
            };

            update = Update.AddToSetWrapped("InnerObjects", d1);
            collection.Update(query, update);

            var d2 = new D {
                X = 2
            };
            var d3 = new D {
                X = 3
            };

            update = Update.AddToSetEachWrapped("InnerObjects", d1, d2, d3);
            collection.Update(query, update);

            var    document = collection.FindOneAs <BsonDocument>();
            var    json     = document.ToJson();
            string expected;

            if (server.BuildInfo.Version >= new Version(2, 6, 0))
            {
                expected = "{ '_id' : ObjectId('#ID'), 'InnerObjects' : [1, { 'X' : 1 }, { 'X' : 2 }, { 'X' : 3 }] }";
            }
            else
            {
                // prior to version 2.5.2 the server would reorder the elements when Update was used
                expected = "{ 'InnerObjects' : [1, { 'X' : 1 }, { 'X' : 2 }, { 'X' : 3 }], '_id' : ObjectId('#ID') }";
            }
            expected = expected.Replace("#ID", id.ToString());
            expected = expected.Replace("'", "\"");
            Assert.AreEqual(expected, json);
        }
예제 #17
0
        protected Task On(ContentDeleted @event, EnvelopeHeaders headers)
        {
            return(ForAppIdAsync(@event.AppId.Id, async collection =>
            {
                await collection.UpdateManyAsync(
                    Filter.And(
                        Filter.AnyEq(x => x.ReferencedIds, @event.ContentId),
                        Filter.AnyNe(x => x.ReferencedIdsDeleted, @event.ContentId)),
                    Update.AddToSet(x => x.ReferencedIdsDeleted, @event.ContentId));

                await collection.DeleteOneAsync(x => x.Id == headers.AggregateId());
            }));
        }
예제 #18
0
        public QueryBuilder <T> UpdateAddToSet <F>(Expression <Func <T, IEnumerable <F> > > collection, F value)
        {
            if (Update == null)
            {
                Update = UpdateBuilder.AddToSet(collection, value);
            }
            else
            {
                Update = Update.AddToSet(collection, value);
            }

            return(this);
        }
예제 #19
0
        public void AddToWatchList(int userId, string watchedUser)
        {
            IMongoQuery  query  = Query.EQ("UserId", userId);
            IMongoUpdate update = Update.AddToSet("WatchList", watchedUser);
            MongoCollection <ManologyUser> usersCollection = DB.GetCollection <ManologyUser>("Users");
            var cursor = usersCollection.FindOne(query);

            if (cursor.WatchList.Count >= 10)
            {
                usersCollection.Update(query, Update.Pull("WatchList", cursor.WatchList[0]));
            }
            usersCollection.Update(query, update, UpdateFlags.Upsert);
        }
예제 #20
0
        public Idea VoteDown(ObjectId id, ObjectId userId)
        {
            Collection.FindAndModify(new FindAndModifyArgs
            {
                Query  = Query <Idea> .Where(i => i.Id == id),
                Update = Update <Idea> .AddToSet(i => i.UsersDown, userId)
                         .Pull(i => i.UsersUp, userId)
            });
            var idea = FindById(id);

            Sync(new SyncEventArgs <IEntity>("save", idea));
            return(idea);
        }
예제 #21
0
        public async Task <ChecklistTask> AddChecklistTask(AddChecklistTaskRequest request)
        {
            var task = new ChecklistTask()
            {
                Order = request.Order,
                Id    = ObjectId.GenerateNewId().ToString(),
                Text  = request.Text
            };
            var update = Update.AddToSet(x => x.ChecklistTasks, task);
            var filter = Filter.Eq(x => x.Id, request.ChecklistId);
            await Collection.UpdateOneAsync(filter, update);

            return(task);
        }
예제 #22
0
        public async Task AddChecklistToUser(string checklistsId, Auth requestAuth, bool isOwned)
        {
            var user = await GetUser(requestAuth);

            var update = Update.AddToSet(x => x.Checklists, new UsersChecklist
            {
                ChecklistId = checklistsId,
                Order       = user.Checklists.Max(y => y.Order) + 1,
                IsOwned     = isOwned
            });

            var filter = Filter.Eq(x => x.Email, requestAuth.Email);
            await Collection.UpdateOneAsync(filter, update);
        }
예제 #23
0
        public void Handle(CommentApproved @event)
        {
            var collection = CreateCollection();

            var postsRepository = new PostsRepository(_mongoDatabase);

            var post = postsRepository.Find(@event.AggregateRootId);

            var comment = post.Comments.First(x => x.Id == @event.CommentId);

            var find = Query.EQ("_id", @event.AggregateRootId);

            var update = Update.AddToSet("Comments", comment.ToBsonDocument());

            collection.Update(find, update);
        }
예제 #24
0
        public void InsertHug(string recipient, Hug hug)
        {
            var mongUserObject = _mongoCollection.AsQueryable().Single(a => a.UserID == new BsonObjectId(recipient));
            var hugs           = mongUserObject.Hugs;

            if (hugs.Any(a => a.SenderID == hug.SenderID)) //No reason to store this - the user has already hugged.
            {
                return;
            }

            hugs.Add(hug);

            var query  = Query.EQ("_id", new BsonObjectId(recipient));
            var update = Update.AddToSet("Hugs", hug.ToBsonDocument());

            _mongoCollection.FindAndModify(query, SortBy.Null, update);
        }
예제 #25
0
        public void TestAddToSetEach()
        {
            var server     = Configuration.TestServer;
            var database   = Configuration.TestDatabase;
            var collection = Configuration.GetTestCollection <C>();

            collection.RemoveAll();
            var c = new C {
                InnerObjects = new List <D>()
            };

            collection.Insert(c);
            var id = c.Id;

            var query  = Query.EQ("_id", id);
            var update = Update.AddToSet("InnerObjects", 1);

            collection.Update(query, update);
            var d1 = new D {
                X = 1
            };

            update = Update.AddToSetWrapped("InnerObjects", d1);
            collection.Update(query, update);

            var d2 = new D {
                X = 2
            };
            var d3 = new D {
                X = 3
            };

            update = Update.AddToSetEachWrapped("InnerObjects", d1, d2, d3);
            collection.Update(query, update);

            var document = collection.FindOneAs <BsonDocument>();
            var json     = document.ToJson();
            var expected = "{ 'InnerObjects' : [1, { 'X' : 1 }, { 'X' : 2 }, { 'X' : 3 }], '_id' : ObjectId('#ID') }"; // server put _id at end?

            expected = expected.Replace("#ID", id.ToString());
            expected = expected.Replace("'", "\"");
            Assert.AreEqual(expected, json);
        }
        //update = Update<MongoProductView>.AddToSet<string>(item => item.Keywords.AsEnumerable(), new string[] { "test" });

        private static void UpdateDocumentsWithNewKeyword()
        {
            var array = new List <string>()
            {
                "new"
            };
            var query = Query <MongoProductView> .All(item => item.Keywords, array);

            //show that we did return a product.
            var found = Collections.ProductViewCollection.Find(query).ToList();
            //Add keyword to all documents that have a keyword of new
            var update = Update.AddToSet("keywords", "test");

            //you could also use push if you wanted it added no matter what.
            //var update = Update.Push("keywords", "test");
            Collections.ProductViewCollection.Update(query, update);

            Console.WriteLine("");
        }
예제 #27
0
        public void TestAddToSetEach()
        {
            var server     = MongoServer.Create("mongodb://localhost/?safe=true");
            var database   = server["onlinetests"];
            var collection = database.GetCollection <C>("csharp111");

            collection.RemoveAll();
            var c = new C {
                InnerObjects = new List <D>()
            };

            collection.Insert(c);
            var id = c.Id;

            var query  = Query.EQ("_id", id);
            var update = Update.AddToSet("InnerObjects", 1);

            collection.Update(query, update);
            var d1 = new D {
                X = 1
            };

            update = Update.AddToSetWrapped("InnerObjects", d1);
            collection.Update(query, update);

            var d2 = new D {
                X = 2
            };
            var d3 = new D {
                X = 3
            };

            update = Update.AddToSetEachWrapped("InnerObjects", d1, d2, d3);
            collection.Update(query, update);

            var document = collection.FindOneAs <BsonDocument>();
            var json     = document.ToJson();
            var expected = "{ 'InnerObjects' : [1, { 'X' : 1 }, { 'X' : 2 }, { 'X' : 3 }], '_id' : { '$oid' : '#ID' } }"; // server put _id at end?

            expected = expected.Replace("#ID", id.ToString());
            expected = expected.Replace("'", "\"");
            Assert.AreEqual(expected, json);
        }
예제 #28
0
        /// <summary>
        /// Registers the video file by media identifier. 'contents.name' is considered unique. If it
        ///     exist, update, else insert
        /// </summary>
        /// <param name="file">The file.</param>
        /// <param name="user">The user.</param>
        void RegisterVideoFileByMediaId(Model.File file, string userName)
        {
            // Gather audit information
            file.ModifiedDatetime = DateTime.UtcNow;
            file.ModifiedBy       = userName;

            // Check if file exist for given media id. If not, insert new file document, else;
            // if it exist, verify if the sub document matches. If so, update
            // existing sub document, else insert new sub document
            MongoCollection <Model.File> fileCollection = _database.GetCollection <Model.File>("File");
            var query = Query.And(Query.EQ("MediaId", file.MediaId), Query.NotExists("AiringId"));

            Model.File dbFile = fileCollection.Find(query).FirstOrDefault();
            if (dbFile == null)
            {
                // Add new file document
                fileCollection.Save(file);
            }
            else
            {
                // This removes existing content if it exists and then inserts.
                foreach (var content in file.Contents)
                {
                    query = Query.And(
                        Query.EQ("MediaId", file.MediaId),
                        Query.NotExists("AiringId"),
                        Query.EQ("Contents.Name", content.Name));

                    // Remove, if it exist
                    var pull = Update <Model.File> .Pull(x => x.Contents, builder => builder.EQ(q => q.Name, content.Name));

                    fileCollection.Update(query, pull);

                    // Insert
                    query = Query.And(Query.EQ("MediaId", file.MediaId), Query.NotExists("AiringId"));
                    fileCollection.Update(query, Update <Model.File> .AddToSet(c => c.Contents, content)
                                          .Set(c => c.ModifiedBy, file.ModifiedBy)
                                          .Set(c => c.ModifiedDatetime, file.ModifiedDatetime));
                }
            }
        }
예제 #29
0
        /// <summary>
        /// Send a friend request
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public JsonResult SendFriendRequest(string userName)
        {
            _dbContext = new MongoContext();
            var   userId = Session["User"];
            Users user   = _dbContext.database.GetCollection <Users>("users").FindOne(Query.EQ("_id", (ObjectId)userId));

            if (user != null)
            {
                Users userToAsk = _dbContext.database.GetCollection <Users>("users").FindOne(Query.EQ("UserName", userName));
                //userToAsk.PendingFriendsRequest.Add(user._id);
                //Ajout de l'id dans notre pending friend request et dans celle de l'utilisateur concernée
                _dbContext.database.GetCollection <Users>("users").FindAndModify(Query.EQ("_id", userToAsk._id), null,
                                                                                 Update.AddToSet("PendingFriendsRequest", user._id));

                _dbContext.database.GetCollection <Users>("users").FindAndModify(Query.EQ("_id", user._id), null,
                                                                                 Update.AddToSet("PendingFriendsRequest", userToAsk._id));
                return(Json(true, JsonRequestBehavior.AllowGet));
            }

            return(Json(false, JsonRequestBehavior.AllowGet));
        }
예제 #30
0
        public void Persist <T>(Guid trackingNumber, T @event) where T : RoutingSlipEventDocument
        {
            IMongoQuery upsertQuery = Query <RoutingSlipDocument> .EQ(x => x.TrackingNumber, trackingNumber);

            WriteConcernResult result = _collection.Update(upsertQuery,
                                                           Update <RoutingSlipDocument> .AddToSet(x => x.Events, @event),
                                                           UpdateFlags.Upsert);

            if (result.Ok == false || result.DocumentsAffected != 1)
            {
                throw new SaveEventException(trackingNumber, "Failed to save the event");
            }

            // if this was the first save, this will be false
            if (result.UpdatedExisting == false)
            {
                if (_log.IsDebugEnabled)
                {
                    _log.DebugFormat("{0} {1}", trackingNumber, typeof(T).Name);
                }
            }
        }