コード例 #1
20
 public async static void InsetOneAsync(IMongoCollection<BsonDocument> collection, BsonDocument input)
 {
     await collection.InsertOneAsync(input);
 }
コード例 #2
8
        public virtual async Task <IdentityResult> CreateAsync(TUser user, CancellationToken token)
        {
            await _Users.InsertOneAsync(user, cancellationToken : token);

            return(IdentityResult.Success);
        }
コード例 #3
6
        /// <summary>
        /// Saves a record to database.
        /// </summary>
        /// <returns>The record.</returns>
        /// <param name="collection">Collection.</param>
        private static async Task SaveRecord(IMongoCollection<PhoneBookRecord> collection)
        {
            Console.WriteLine("Enter a name:");
            string name = Console.ReadLine();
            Console.WriteLine("Enter a phone:");
            string phone = Console.ReadLine();

            PhoneBookRecord record = new PhoneBookRecord(){ Name = name, Phone = phone };

            await collection.InsertOneAsync(record);
        }
コード例 #4
0
 public async Task Create(
     T entity,
     CancellationToken cancellationToken) =>
 await _entities?.InsertOneAsync(
     entity,
     null,
     cancellationToken);
コード例 #5
0
ファイル: Database.cs プロジェクト: RoiNeuman/ChatApp
 // To save item (_item) in a collection (_col) use: _col.SaveAsync(_item);
 public static void SaveAsync <T>(this IMongoCollection <T> collection, T entity)
     where T : IIdentified
 {
     if (collection == null)
     {
         CreateConnection();
     }
     collection?.InsertOneAsync(entity);
 }
コード例 #6
0
ファイル: InsertOneTest.cs プロジェクト: RavenZZ/MDRelation
 protected override void Execute(IMongoCollection<BsonDocument> collection, BsonDocument outcome, bool async)
 {
     if (async)
     {
         collection.InsertOneAsync(_document).GetAwaiter().GetResult();
     }
     else
     {
         collection.InsertOne(_document);
     }
 }
コード例 #7
0
        public async Task ExecuteAsync(UpsertClimbCommandParameters parameters, IMongoCollection<Climb> collection)
        {
            var climb = new Climb
            {
                Id = parameters.Id,
                LatLong = parameters.LatLong,
                Rating = parameters.Rating,
                Styles = parameters.Styles,
                Name = parameters.Name
            };

            if (parameters.Id == Guid.Empty)
            {
                await collection.InsertOneAsync(climb);
            }
            else
            {
                var filter = Builders<Climb>.Filter.Eq(c => c.Id == climb.Id, true);
                await collection.UpdateOneAsync(filter, new ObjectUpdateDefinition<Climb>(climb));
            }
        }
コード例 #8
0
        private async Task GetFutureTweets(string user, IMongoCollection<BsonDocument> tweets)
        {
            int tweetsCount = 0, tweetsProcessed = 0, tweetsMax = MaxTweets;
            var filter = GetFilter(user);
            var aggdef = tweets.Aggregate()
                .Match(filter)
                .Group(new BsonDocument { { "_id", "$user.screen_name" }, { "max", new BsonDocument("$max", "$id") } });
            var aggresult = await aggdef.FirstOrDefaultAsync();
            var maxid = aggresult["max"].AsNullableInt64;

          


            do
            {
                var query = string.Format(api_path, user);

                if (maxid.HasValue)
                {
                    query = query + "&since_id={0}";
                    query = string.Format(query, maxid + 1);
                }

                var jsonObject = TwitterDownloader.ExecuteJsonGETQuery(query);
                List<object> otweets = (List<object>)JsonConvert.DeserializeObject<List<object>>(jsonObject);
                tweetsCount = otweets.Count;
                tweetsProcessed += tweetsCount;
                _log.Info("Getting {0} new tweets for user:{1}", otweets.Count, user);

                foreach (object oTweet in otweets)
                {
                    var bson = BsonDocument.Parse(oTweet.ToString());
                    tweets.InsertOneAsync(bson).Wait();
                    long? nmax = bson["id"].AsNullableInt64;
                    if (nmax > maxid)
                        maxid = nmax;
                }
            }
            while (tweetsCount > 0 && tweetsProcessed < tweetsMax);
        }
コード例 #9
0
        public async Task Upsert(OrderDocument order)
        {
            var existing = await GetOrderAsync(order.OrderId);

            var b = new BsonDocument("$set", order.ToBsonDocument());

            try
            {
                if (existing != null)
                {
                    await collection?.UpdateOneAsync <OrderDocument>
                        (e => e.OrderId == order.OrderId, b);
                }
                else
                {
                    await collection?.InsertOneAsync(order);
                }
            }
            catch (Exception ex)
            {
                logger.LogError("$Error while upsering doc in Mongo " + ex.Message);
                throw  new Exception(ex.Message);
            }
        }
 public async Task Insert(TEntity entity)
 {
     IMongoCollection <TEntity> collection = this.GetAll();
     await collection.InsertOneAsync(entity);
 }
コード例 #11
0
		private async Task CreateAdmin(IMongoCollection<UserModel> users)
		{
 			await users.Indexes.CreateOneAsync(
				Builders<UserModel>.IndexKeys.Ascending(u => u.Name),
				new CreateIndexOptions { Unique = true, });

			if (await users.CountAsync(_ => true) == 0)
			{
				await users
					.InsertOneAsync(
					new UserModel
					{
						Name = AdminName,
						Password = AdminPassword,
						Roles = AdminRoles
					});
			}
		}
コード例 #12
0
        public Task AddStockSymbolDataAsync(StockValue DataPoint)
        {
            IMongoCollection <StockValue> collection = _database.GetCollection <StockValue>(_stockDataCollectionName);

            return(collection.InsertOneAsync(DataPoint));
        }
コード例 #13
0
        public async Task <Shared.Models.Appraisal> CreateAsync(Shared.Models.Appraisal newAppraisal)
        {
            await _Appraisals.InsertOneAsync(newAppraisal);

            return(await Task.FromResult <Shared.Models.Appraisal>(newAppraisal));
        }
コード例 #14
0
 public async Task CreateAsync(QuizResult item)
 {
     await _collection.InsertOneAsync(item);
 }
コード例 #15
0
 static async Task InsertCustomer(IMongoCollection<Customer> collection)
 {
     await collection.InsertOneAsync(new Customer());
 }
コード例 #16
0
        public async Task <MealType> CreateAsync(MealType MealType)
        {
            await _meal.InsertOneAsync(MealType);

            return(MealType);
        }
コード例 #17
0
 public virtual Task InsertOneAsync(TDocument document)
 {
     return(Task.Run(() => _collection.InsertOneAsync(document)));
 }
コード例 #18
0
        /// <summary>
        /// Insert a entity in database
        /// </summary>
        /// <param name="entity">Entity to insert</param>
        /// <returns>Inserted entity</returns>
        public async Task <TDocument> Insert(TDocument entity)
        {
            await _collection.InsertOneAsync(entity);

            return(entity);
        }
コード例 #19
0
        public async Task <Customer> CreateAsync(Customer customer)
        {
            await _customer.InsertOneAsync(customer);

            return(customer);
        }
コード例 #20
0
 public async Task InsertCryptoData(ICryptoDataDomain cryptoDataDomain)
 {
     var mongoCryptoDataDomain = Mapper.Map <MongoCryptoDataDomain>(cryptoDataDomain);
     await _mongoCollection.InsertOneAsync(mongoCryptoDataDomain);
 }
コード例 #21
0
        public async Task <T> Add(T item)
        {
            await _items.InsertOneAsync(item);

            return(item);
        }
コード例 #22
0
        private async Task GetHistoricalTweets(string user, IMongoCollection<BsonDocument> tweets)
        {
            int tweetsCount = 0, tweetsProcessed = 0, tweetsMax = MaxTweets;
            //var filter = GetFilter(user);
            //var aggdef = tweets.Aggregate()
            //    .Match(filter)
            //    .Group(new BsonDocument { { "_id", "$user.screen_name" }, { "min", new BsonDocument("$min", "$id") } });
            //var aggresult = await aggdef.FirstOrDefaultAsync();
            //var minid = aggresult != null ? aggresult["min"].AsNullableInt64 : null;

           
            //do
            //{
                var query = string.Format(api_path, user);

                //if (minid.HasValue)
                //{
                //    query = query + "&max_id={0}";
                //    query = string.Format(query, minid - 1);
                //}

                var jsonObject = TwitterDownloader.ExecuteJsonGETQuery(query);

                if (jsonObject == null)
                    return;

                List<object> otweets = (List<object>)JsonConvert.DeserializeObject<List<object>>(jsonObject);
                tweetsCount = otweets.Count;
                tweetsProcessed += tweetsCount;
                Console.WriteLine("Getting {0} old tweets for user:{1}", otweets.Count, user);

                foreach (object oTweet in otweets)
                {
                    var bson = BsonDocument.Parse(oTweet.ToString());
                    tweets.InsertOneAsync(bson).Wait();
                    //minid = bson["id"].AsNullableInt64;
                }
            //}
            //while (tweetsCount > 0 && tweetsProcessed < tweetsMax);
        }
コード例 #23
0
        public async Task <TaskEntity> Create(TaskEntity task)
        {
            await _TasksCollection.InsertOneAsync(task);

            return(task);
        }
コード例 #24
0
        //Create
        public async Task <TreeHistory> Create(TreeHistory history)
        {
            await repos.InsertOneAsync(history);

            return(history);
        }
コード例 #25
0
        public async Task InsertWithDuplicateKey()
        {
            /* In a concurrent system, your app might try to save a document that
             * has a duplicate value on a field that is marked unique. When this
             * happens, MongoDB returns a Duplicate Key error.
             *
             * To show this, let's add a Theater document to a collection, and
             * then add a new document with the same Id value as the first
             * Theater. We're using the Id field because it maps to the _id field
             * in Mongo, and _id is a field that is always marked as unique.
             */

            var testTheater = new Theater(10101010, "234 Bar Ave.", "Wishywashy", "WY", "87654");
            await _theatersCollection.InsertOneAsync(testTheater);

            /* You may recall from a previous lesson that in our Theater class,
             * we don't assign a value to the Id field; we let MongoDB do that
             * for us. When the call to InsertOne or InsertOneAsync returns,
             * our new Theater object has that field populated for us!
             *
             * So let's now use that existing Id value to create and insert a
             * new Theater object:
             */

            var myNewTheater = new Theater()
            {
                Id = testTheater.Id
            };

            /* This call should fail with an exception:
             */

            Assert.Throws <MongoWriteException>(() =>
                                                _theatersCollection.InsertOne(myNewTheater));

            /* Now that we've confirmed this, we can wrap our writes in
             * try-catch blocks to handle exceptions accordingly. While a Duplicate
             * Key error is unlikely to happen, especially if you let MongoDB
             * handle assigning a value to the _id field for you, it's always a
             * best practice to use try-catch blocks. And if you are managing
             * a field of unique values in your code, you'll definitely want
             * to be handling this exception!
             */

            try
            {
                await _theatersCollection.InsertOneAsync(myNewTheater);
            }

            catch (MongoWriteException ex)
            {
                /* There are, of course, other potential write errors, so
                 * let's make sure we really caught a dupliate key error:
                 */
                Assert.IsTrue(ex.Message.Contains("E11000 duplicate key error"));

                /* If you have a custom process for generating unique key values,
                 * this would be a good place to change the Id value and re-try
                 * the Insert.
                 */
            }
        }
コード例 #26
0
        public async Task <T> Create(T entity)
        {
            await _entities.InsertOneAsync(entity);

            return(entity);
        }
コード例 #27
0
 public async Task Insert(Product details)
 {
     await collection.InsertOneAsync(details);
 }
コード例 #28
0
ファイル: ContactService.cs プロジェクト: Esaban17/ChatAPI
        public async Task <Contact> CreateContact(Contact newContact)
        {
            await _contacts.InsertOneAsync(newContact);

            return(newContact);
        }
コード例 #29
0
 public async Task AddAsync(Document document)
 => await _documents.InsertOneAsync(document);
コード例 #30
0
ファイル: Repository.cs プロジェクト: g-ninja-academy/ninjag
 public async Task Add(TEntity entity)
 {
     await _collection.InsertOneAsync(entity);
 }
コード例 #31
0
ファイル: Program.cs プロジェクト: sshev4enko/tandd
        /// <summary>
        /// Insert a new single document (SQL=row) in the collection (SQL=table).
        /// </summary>
        private static void InsertOne(IMongoCollection<BsonDocument> collection)
        {
            Console.WriteLine("++ Insert a new single document (SQL=row) in the collection (SQL=table).");

            //var document = new BsonDocument { {"_id", ObjectId.GenerateNewId()}, { "THE NEW ROW", "Document 1234567890" } };
            var document = new BsonDocument().AddRange(newObj);
            Task t = collection.InsertOneAsync(document);
            t.Wait();

            Console.WriteLine("  status = " + t.Status);
        }
コード例 #32
0
 public virtual Task InsertOneAsync(T document)
 {
     document.Id = MongoDB.Bson.ObjectId.GenerateNewId().ToString();
     return(Task.Run(() => _collection.InsertOneAsync(document)));
 }
コード例 #33
0
        public async Task <string> InsertOneArtistAsync(Artist artist)
        {
            await _collection.InsertOneAsync(artist);

            return(artist.Id.ToString());
        }
コード例 #34
0
 public TryOptionAsync <T> CreateDocumentAsync(T item) =>
 TryOptionAsync(async() =>
 {
     await _collection.InsertOneAsync(item);
     return(Some(item));
 });
コード例 #35
0
ファイル: AnalyticsRepository.cs プロジェクト: Muja98/SOA
 public async Task AddDataFromSensors(SmartHomeTemperature sht)
 {
     await _smartHome.InsertOneAsync(sht);
 }
コード例 #36
0
 public async Task CreateDevice(Device dev)
 {
     await DeviceCollection.InsertOneAsync(dev);
 }
コード例 #37
0
 public async Task Create(EventEntity eventEntity)
 {
     eventEntity.Created = DateTime.Now;
     eventEntity.Deleted = false;
     await _eventsCollection.InsertOneAsync(eventEntity);
 }
コード例 #38
0
ファイル: Api.cs プロジェクト: kay-kim/mongo-csharp-driver
        private async Task DoWork(IMongoCollection<BsonDocument> collection)
        {
            var rand = new Random();
            while (!_cancellationTokenSource.IsCancellationRequested)
            {
                var i = rand.Next(0, 10000);
                List<BsonDocument> docs;
                try
                {
                    docs = await collection.Find(new BsonDocument("i", i))
                        .ToListAsync(_cancellationTokenSource.Token);
                }
                catch
                {
                    Console.Write("+");
                    continue;
                }

                if (docs.Count == 0)
                {
                    try
                    {
                        await collection.InsertOneAsync(new BsonDocument("i", i), _cancellationTokenSource.Token);
                    }
                    catch
                    {
                        Console.Write("*");
                    }
                }
                else
                {
                    try
                    {
                        var filter = new QueryDocument("_id", docs[0]["_id"]);
                        var update = new UpdateDocument("$set", new BsonDocument("i", i + 1));
                        await collection.UpdateOneAsync(filter, update, cancellationToken: _cancellationTokenSource.Token);
                        //Console.Write(".");
                    }
                    catch (Exception)
                    {
                        Console.Write("*");
                    }
                }
            }
        }
コード例 #39
0
ファイル: Program.cs プロジェクト: johnnytorres/twitterlc
        private static async Task Dr(IMongoCollection<BsonDocument> leaders, BsonDocument filter, IMongoCollection<BsonDocument> users, IMongoCollection<BsonDocument> leadersbak)
        {
            using (var cursor = await leaders.FindAsync(filter))
            {

                while (await cursor.MoveNextAsync())
                {
                    var batch = cursor.Current;
                    foreach (var rt in batch)
                    {
                        BsonArray bRetweeters = rt["retweeters_id"].AsBsonArray;

                        //if (bRetweeters.Count == 0)
                        //    continue;

                        foreach (var bUser in bRetweeters)
                        {
                            var lUser = bUser.ToInt64();
                            try
                            {

                                log.Info("readling retweeter {0}", lUser);
                                var usersFilter = Builders<BsonDocument>.Filter.Eq("id", lUser);
                                var result = await users.Find(usersFilter).ToListAsync();
                                if (result.Count > 0)
                                    continue;

                                log.Info("downloading retweeter {0}", lUser);
                                TwitterProfileHandler profileHandler = new TwitterProfileHandlerMongo();
                                string screenName = profileHandler.Download(lUser);
                                //TwitterHomelineHandler homeHandler = new TwitterHomelineHandlerMongo();
                                //homeHandler.Download(screenName);
                            }
                            catch (Exception ex)
                            {
                                string msg = "Error trying to download profile for user:{0}";
                                msg = string.Format(msg, lUser);
                                log.Error(ex, msg);
                            }
                        }

                        //rt["done"] = true;
                        //var filterupdate = Builders<BsonDocument>.Filter.Eq("_id", rt["_id"]);
                        //var update = Builders<BsonDocument>.Update.Push("done", true);
                        //await leaders.UpdateOneAsync(filterupdate, rt);
                        await leadersbak.InsertOneAsync(rt);
                        var filterbak = Builders<BsonDocument>.Filter.Eq("_id", rt["_id"]);
                        await leaders.DeleteOneAsync(filterbak);
                    }
                }
            }

            Thread.Sleep(5000);
        }
コード例 #40
0
ファイル: Program.cs プロジェクト: ax2015/testprojects
        static async Task AddDocuments(IMongoCollection<Person> collection)
        {
            var testdoc = new Person ("jones");
            testdoc.Age = 30;
            testdoc.Profession = "hacker";

            var nestedArray = new List<string>();
            nestedArray.Add("color");
            nestedArray.Add("red");
            testdoc.Preferences = nestedArray;
            await collection.InsertOneAsync(testdoc);
            Console.WriteLine("Adding:" + testdoc.ToBsonDocument().ToString());

            var testdoc2 = new Person("jones");
            testdoc2.Age = 50;
            testdoc2.Profession = "retired hacker";
            await collection.InsertOneAsync(testdoc2);
            Console.WriteLine("Adding:" + testdoc2.ToBsonDocument().ToString());

            var doc2 = new Person("Smith");
            var doc3 = new Person("White");
            await collection.InsertManyAsync(new[] { doc2, doc3 });
            Console.WriteLine("Adding:" + doc2.ToBsonDocument().ToString() + "\nAdding:" + doc3.ToBsonDocument().ToString());
        }
コード例 #41
0
 public async void InsertDocumentInCollection(BsonDocument document, IMongoCollection<BsonDocument> collection)
 {
     await  collection.InsertOneAsync(document);
 }
コード例 #42
0
ファイル: Form1.cs プロジェクト: JOKAZ12345/u-mad-braWLER
 private static async Task AddMongo(BsonDocument doc, IMongoCollection<BsonDocument> collection)
 {
     await collection.InsertOneAsync(doc);
 }
コード例 #43
-1
        private static void InsertToDatabase(IMongoCollection<EnergyDrink> collection)
        {
            Console.Clear();
            Console.Write("Enter the name of the drink:");
            var name = Console.ReadLine();
            Console.Write("\nEnter the price of the drink:");
            var price = double.Parse(Console.ReadLine());

            var energyDrink = new EnergyDrink(name, price);
            collection.InsertOneAsync(energyDrink);

            Console.WriteLine("The drink was successfuly added");
            Console.WriteLine("\nPress any key to continue..");
            Console.ReadLine();
        }
コード例 #44
-1
        private static void InsertOneAsyncTo(IMongoCollection<Category> coll)
        {
            var category = new Category
            {
                Id = ObjectId.GenerateNewId(),
                Name = "Category 1",
                Description = "Category Description",
                Expenses = new List<Expense>
                {
                    new Expense
                    {
                        Id = ObjectId.GenerateNewId(),
                       Amount = 12,
                       Date = DateTime.Today,
                       Transaction = RandomValueGen.GetRandomString(5)
                    }
                }
            };

            coll.InsertOneAsync(category).Wait();
        }
コード例 #45
-1
ファイル: Api.cs プロジェクト: kay-kim/mongo-csharp-driver
 private async Task InsertData(IMongoCollection<BsonDocument> collection)
 {
     for (int i = 0; i < 100; i++)
     {
         await collection.InsertOneAsync(new BsonDocument("i", i), _cancellationTokenSource.Token);
     }
 }
コード例 #46
-1
 public async Task Create(ProcessEntity process)
 {
     process.Created = DateTime.Now;
     process.Deleted = false;
     await _processsServicesCollection.InsertOneAsync(process);
 }
コード例 #47
-9
 protected override Task ExecuteAsync(IMongoCollection<BsonDocument> collection, BsonDocument outcome)
 {
     return collection.InsertOneAsync(_document);
 }
コード例 #48
-21
 public Task Create(Comment comment)
 {
     return(_comments.InsertOneAsync(comment));
 }