public static async Task<int> DeleteAsync(IMongoCollection<BsonDocument> collection, params object[] keyValues)
{
if (keyValues.Length == 0)
throw new ArgumentException("At least 1 keyValue required.");
if (keyValues.Length == 1)
{
var ret = await collection.DeleteOneAsync(Builders<BsonDocument>.Filter.Eq("_id", keyValues[0]));
return ret != null ? (int)ret.DeletedCount : 0;
}
else
{
var keyPath = ToDotPath(keyValues.Skip(1));
var ret = await collection.UpdateOneAsync(Builders<BsonDocument>.Filter.Eq("_id", keyValues[0]),
Builders<BsonDocument>.Update.Unset(keyPath));
return ret != null ? (int)ret.ModifiedCount : 0;
}
}
public async Task <bool> Delete(string id)
{
await _Spells.DeleteOneAsync(x => x.Id == id);
return(true);
}
public Task RemoveAsync(string id) => collection.DeleteOneAsync(c => c.Id == id);
public Task DeleteAsync(TUser user)
{
IMongoCollection <TUser> userCollection = GetCollection <TUser>(UserCollectionName);
return(userCollection.DeleteOneAsync(Builders <TUser> .Filter.Eq("Id", ((IIdentityUser <TUserId>)user).Id)));
}
/// <inheritdoc />
public Task <DeleteResult> RemoveAsync(ObjectId objectId)
{
return(_mongoCollection.DeleteOneAsync(Builders <T> .Filter.Eq("_id", objectId)));
}
public async Task Delete(int planId)
{
await _plans.DeleteOneAsync(p => p.Id == planId);
}
public async Task DeleteItemAsync(Guid id)
{
var filter = _filterBuilder.Eq(item => item.Id, id);
await _itemsCollection.DeleteOneAsync(filter);
}
public async Task Delete(string id) => await _labBenches.DeleteOneAsync <LabBench>(labBench => labBench.Id == id);
public async Task DeleteObjectiveFunction(Guid id)
{
await _objectiveFunctionsCollection.DeleteOneAsync(x => x.Id == id);
}
public async Task DeleteVariable(Guid id)
{
await _variablesCollection.DeleteOneAsync(x => x.Id == id);
}
public async Task DeleteComment(string commentId)
{
await Comments.DeleteOneAsync(x => x.CommentId == commentId);
}
public virtual void Remove(Guid id)
{
_context.AddCommand(() => _dbSet.DeleteOneAsync(Builders <TEntity> .Filter.Eq("_id", id)));
}
public async Task <bool> DeleteViewAsync(string viewId)
{
var deleteResult = await viewCollection.DeleteOneAsync(x => x.Id == viewId);
return(deleteResult.IsAcknowledged && deleteResult.DeletedCount == 1);
}
public Task DeleteAsync(TUser obj) => _users.DeleteOneAsync(x => x.Id == obj.Id);
public Task <DeleteResult> Remove(
T entity,
CancellationToken cancellationToken) =>
_entities?.DeleteOneAsync(
ent => ent.Id == entity.Id,
cancellationToken);
public async Task Remove(Guid id)
{
var filter = Builders <InvalidCaseReportFromUnknownDataCollector> .Filter.Eq(c => c.Id, id);
await _collection.DeleteOneAsync(filter);
}
public async Task DeleteConstraint(Guid id)
{
await _constraintsCollection.DeleteOneAsync(x => x.Id == id);
}
public virtual Task RemoveAsync(Guid key)
{
return(_collection
.DeleteOneAsync(t => t.Id == key));
}
public async Task DeleteComposedModel(Guid id)
{
await _composedModelsCollection.DeleteOneAsync(x => x.Id == id);
}
public static async Task DeleteAsync(IMongoCollection <InvoiceEntity> collection, InvoiceEntity document)
{
await collection.DeleteOneAsync(x => x.Id == document.Id);
}
public async Task DeleteSet(Guid id)
{
await _setsCollection.DeleteOneAsync(x => x.Id == id);
}
public async Task DeleteAsync(string id)
{
await _citys.DeleteOneAsync(s => s.Id == id);
}
public async Task DeleteParameter(Guid id)
{
await _parametersCollection.DeleteOneAsync(x => x.Id == id);
}
public async Task Remove(Profile profileIn)
{
await _profiles.DeleteOneAsync(profiles => profiles.Id == profileIn.Id);
}
//delete document
public async Task Remove(string id)
{
await Products.DeleteOneAsync(new BsonDocument("_id", new ObjectId(id)));
}
public async Task <IdentityResult> DeleteAsync(TRole role, CancellationToken cancellationToken)
{
var result = await _rolesCollection.DeleteOneAsync(r => r.Id == role.Id, cancellationToken);
return(result.IsAcknowledged ? IdentityResult.Success : IdentityResult.Failed());
}
public async Task DeleteAsync(Guid id)
{
await _quizzes.DeleteOneAsync(x => x.Id == id).ConfigureAwait(false);
}
public Task RemoveAsync(Guid key, CancellationToken cancellationToken = default)
{
return(_collection.DeleteOneAsync(Id(key), cancellationToken: cancellationToken));
}
public async Task DeleteWinePurchaseAsync(string winePurchaseId) => await _winepurchases.DeleteOneAsync(winepurchase => winepurchase.Id == winePurchaseId).ConfigureAwait(false);
public async Task DeleteAsync(string id)
{
await _menuMongo.DeleteOneAsync(x => x.Id == id);
}
private async Task DeleteInstance(Guid id)
{
await context.AddCommand(() => dbSet.DeleteOneAsync(Builders <TEntity> .Filter.Eq("Id", id)));
}
public async Task ExecuteAsync(DeleteClimbCommandParameters parameters, IMongoCollection<Climb> collection)
{
var filter = Builders<Climb>.Filter.Eq(c => c.Id == parameters.Id, true);
await collection.DeleteOneAsync(filter);
}
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 findDocuments(IMongoCollection<student> collection, FilterDefinition<student> searchFilter)
{
//Option 1: for iterting over many documents on the server.
Console.WriteLine("--------------------------------------------------------------------");
using (var cursor = await collection.Find(searchFilter)
.Sort("{student_id:1, score:-1}")
.ToCursorAsync())
{
int i = 1;
using (StreamWriter w = File.AppendText("c:\\data\\test2.txt"))
{
while (await cursor.MoveNextAsync()) //iterate over each batch
{
foreach (var doc in cursor.Current)
{
string text = i + " :=> sid: " + doc.student_id + ":" + doc.score;
Console.WriteLine(text);
w.WriteLine(text);
if (i % 4 == 0)
{
Console.WriteLine("lowest score for " + doc.student_id + " is " + doc.score);
w.WriteLine("lowest score for " + doc.student_id + " is " + doc.score);
await collection.DeleteOneAsync(a => a.Id == doc.Id);
}
i++;
}
}
}
}
}
