public async static void InsetOneAsync(IMongoCollection<BsonDocument> collection, BsonDocument input)
{
await collection.InsertOneAsync(input);
}
public virtual async Task <IdentityResult> CreateAsync(TUser user, CancellationToken token)
{
await _Users.InsertOneAsync(user, cancellationToken : token);
return(IdentityResult.Success);
}
/// <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);
}
public async Task Create(
T entity,
CancellationToken cancellationToken) =>
await _entities?.InsertOneAsync(
entity,
null,
cancellationToken);
// 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);
}
protected override void Execute(IMongoCollection<BsonDocument> collection, BsonDocument outcome, bool async)
{
if (async)
{
collection.InsertOneAsync(_document).GetAwaiter().GetResult();
}
else
{
collection.InsertOne(_document);
}
}
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));
}
}
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);
}
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);
}
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
});
}
}
public Task AddStockSymbolDataAsync(StockValue DataPoint)
{
IMongoCollection <StockValue> collection = _database.GetCollection <StockValue>(_stockDataCollectionName);
return(collection.InsertOneAsync(DataPoint));
}
public async Task <Shared.Models.Appraisal> CreateAsync(Shared.Models.Appraisal newAppraisal)
{
await _Appraisals.InsertOneAsync(newAppraisal);
return(await Task.FromResult <Shared.Models.Appraisal>(newAppraisal));
}
public async Task CreateAsync(QuizResult item)
{
await _collection.InsertOneAsync(item);
}
static async Task InsertCustomer(IMongoCollection<Customer> collection)
{
await collection.InsertOneAsync(new Customer());
}
public async Task <MealType> CreateAsync(MealType MealType)
{
await _meal.InsertOneAsync(MealType);
return(MealType);
}
public virtual Task InsertOneAsync(TDocument document)
{
return(Task.Run(() => _collection.InsertOneAsync(document)));
}
/// <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);
}
public async Task <Customer> CreateAsync(Customer customer)
{
await _customer.InsertOneAsync(customer);
return(customer);
}
public async Task InsertCryptoData(ICryptoDataDomain cryptoDataDomain)
{
var mongoCryptoDataDomain = Mapper.Map <MongoCryptoDataDomain>(cryptoDataDomain);
await _mongoCollection.InsertOneAsync(mongoCryptoDataDomain);
}
public async Task <T> Add(T item)
{
await _items.InsertOneAsync(item);
return(item);
}
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);
}
public async Task <TaskEntity> Create(TaskEntity task)
{
await _TasksCollection.InsertOneAsync(task);
return(task);
}
//Create
public async Task <TreeHistory> Create(TreeHistory history)
{
await repos.InsertOneAsync(history);
return(history);
}
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.
*/
}
}
public async Task <T> Create(T entity)
{
await _entities.InsertOneAsync(entity);
return(entity);
}
public async Task Insert(Product details)
{
await collection.InsertOneAsync(details);
}
public async Task <Contact> CreateContact(Contact newContact)
{
await _contacts.InsertOneAsync(newContact);
return(newContact);
}
public async Task AddAsync(Document document) => await _documents.InsertOneAsync(document);
public async Task Add(TEntity entity)
{
await _collection.InsertOneAsync(entity);
}
/// <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);
}
public virtual Task InsertOneAsync(T document)
{
document.Id = MongoDB.Bson.ObjectId.GenerateNewId().ToString();
return(Task.Run(() => _collection.InsertOneAsync(document)));
}
public async Task <string> InsertOneArtistAsync(Artist artist)
{
await _collection.InsertOneAsync(artist);
return(artist.Id.ToString());
}
public TryOptionAsync <T> CreateDocumentAsync(T item) =>
TryOptionAsync(async() =>
{
await _collection.InsertOneAsync(item);
return(Some(item));
});
public async Task AddDataFromSensors(SmartHomeTemperature sht)
{
await _smartHome.InsertOneAsync(sht);
}
public async Task CreateDevice(Device dev)
{
await DeviceCollection.InsertOneAsync(dev);
}
public async Task Create(EventEntity eventEntity)
{
eventEntity.Created = DateTime.Now;
eventEntity.Deleted = false;
await _eventsCollection.InsertOneAsync(eventEntity);
}
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("*");
}
}
}
}
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);
}
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());
}
public async void InsertDocumentInCollection(BsonDocument document, IMongoCollection<BsonDocument> collection)
{
await collection.InsertOneAsync(document);
}
private static async Task AddMongo(BsonDocument doc, IMongoCollection<BsonDocument> collection)
{
await collection.InsertOneAsync(doc);
}
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();
}
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();
}
private async Task InsertData(IMongoCollection<BsonDocument> collection)
{
for (int i = 0; i < 100; i++)
{
await collection.InsertOneAsync(new BsonDocument("i", i), _cancellationTokenSource.Token);
}
}
public async Task Create(ProcessEntity process)
{
process.Created = DateTime.Now;
process.Deleted = false;
await _processsServicesCollection.InsertOneAsync(process);
}
protected override Task ExecuteAsync(IMongoCollection<BsonDocument> collection, BsonDocument outcome)
{
return collection.InsertOneAsync(_document);
}
public Task Create(Comment comment)
{
return(_comments.InsertOneAsync(comment));
}