async Task IBotDataStore <BotData> .SaveAsync(IAddress key, BotStoreType botStoreType, BotData botData,
CancellationToken cancellationToken)
{
try
{
var requestOptions = new RequestOptions()
{
AccessCondition = new AccessCondition()
{
Type = AccessConditionType.IfMatch,
Condition = botData.ETag
}
};
var entity = new DocDbBotDataEntity(key, botStoreType, botData);
var entityKey = DocDbBotDataEntity.GetEntityKey(key, botStoreType);
if (string.IsNullOrEmpty(botData.ETag))
{
await documentClient.CreateDocumentAsync(UriFactory.CreateDocumentCollectionUri(databaseId, collectionId), entity, requestOptions);
}
else if (botData.ETag == "*")
{
if (botData.Data != null)
{
await documentClient.UpsertDocumentAsync(UriFactory.CreateDocumentCollectionUri(databaseId, collectionId), entity, requestOptions);
}
else
{
await documentClient.DeleteDocumentAsync(UriFactory.CreateDocumentUri(databaseId, collectionId, entityKey), requestOptions);
}
}
else
{
if (botData.Data != null)
{
await documentClient.ReplaceDocumentAsync(UriFactory.CreateDocumentUri(databaseId, collectionId, entityKey), entity, requestOptions);
}
else
{
await documentClient.DeleteDocumentAsync(UriFactory.CreateDocumentUri(databaseId, collectionId, entityKey), requestOptions);
}
}
}
catch (DocumentClientException e)
{
//if (e.StatusCode.HasValue && e.StatusCode.Value == HttpStatusCode.Conflict)
//{
// throw new HttpException((int)HttpStatusCode.PreconditionFailed, e.Message, e);
//}
//throw new HttpException(e.StatusCode.HasValue ? (int)e.StatusCode.Value : 0, e.Message, e);
throw;
}
}
public virtual async Task <IdentityResult> DeleteAsync(TRole role, CancellationToken token)
{
if (UsesPartitioning)
{
await DeleteMapping(role.NormalizedName);
}
await _Client.DeleteDocumentAsync(GetRoleUri(role.DocId), GetRequestOptions(role.PartitionKey));
// todo low priority result based on delete result
return(IdentityResult.Success);
}
public async Task <bool> RemoveAsync(T entity)
{
if (!string.IsNullOrEmpty(entity.Self))
{
var resp = await _client.DeleteDocumentAsync(entity.Self);
return(resp.StatusCode == System.Net.HttpStatusCode.NoContent);
}
else
{
return(false);
}
}
public async Task <bool> Delete(string id)
{
try
{
await _documentClient.DeleteDocumentAsync(CreateDocumentUri(id), RequestOptions);
return(true);
}
catch (DocumentClientException e) when(e.StatusCode == HttpStatusCode.NotFound)
{
return(false);
}
}
public async Task <bool> DeleteUser(User.Domain.User user)
{
var response = await _documentClient.DeleteDocumentAsync(CreateDocumentUri(user.Id),
new RequestOptions { PartitionKey = new PartitionKey(user.Id) });
return(response.StatusCode == HttpStatusCode.NoContent);
}
public async Task <int> DeleteAsync(Expression <Func <EventStoreDocument, bool> > predicate,
CancellationToken cancellationToken = default
)
{
var count = 0;
await ExecuteAsync(async dbCol =>
{
var docs = await GetAsync <EventStoreDocument>(predicate, cancellationToken);
foreach (var doc in docs)
{
await _client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(dbCol.DatabaseId, dbCol.CollectionId, doc.Id),
new RequestOptions
{
PartitionKey = new PartitionKey(doc.StreamId),
JsonSerializerSettings = _jsonSettings
},
cancellationToken
);
count++;
}
},
cancellationToken
);
return(count);
}
public async Task <Document> DeleteDocumentAsync(string documentId, RequestOptions options = null,
CancellationToken cancellationToken = default(CancellationToken))
{
var uri = UriFactory.CreateDocumentUri(_databaseName, _collectionName, documentId);
return(await _documentClient.DeleteDocumentAsync(uri, options, cancellationToken));
}
public static async Task <IActionResult> Delete(
[HttpTrigger(
AuthorizationLevel.Function,
"delete",
Route = "jurisdiction/{jurisdiction}/person/{id}")]
HttpRequest req,
string jurisdiction,
string id,
[CosmosDB(
Databases.MyApp.Name,
Databases.MyApp.Collections.People.Name,
ConnectionStringSetting = Databases.MyApp.ConnectionStringPropertyName,
Id = "{id}",
PartitionKey = "{jurisdiction}",
CreateIfNotExists = true)]
Person toDelete,
[CosmosDB(ConnectionStringSetting = Databases.MyApp.ConnectionStringPropertyName)]
IDocumentClient client,
ILogger log,
CancellationToken cancellationToken)
{
if (toDelete == null)
{
return(new BadRequestErrorMessageResult(
$"Person with jurisdiction \"{jurisdiction}\" and ID \"{id}\" not found. Cannot Delete."));
}
await client.DeleteDocumentAsync(toDelete.SelfLink, new RequestOptions
{
PartitionKey = new PartitionKey(jurisdiction)
}, cancellationToken);
return(new AcceptedResult());
}
public async Task <bool> DeleteAsync(string id, Domain.RequestOptions options = null)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new ArgumentException("Missing document Id", nameof(id));
}
if (_databaseName == null)
{
throw new DataStoreException("Connect must be called to delete from CosmosDB");
}
try
{
var response = await _client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(_databaseName, _collectionName, id), options.ToRequestOptions(), _cancellationToken);
return(response.StatusCode == HttpStatusCode.NoContent);
}
catch (DocumentClientException e)
{
if (e.StatusCode == HttpStatusCode.NotFound)
{
return(true);
}
throw;
}
}
public async Task <bool> DeleteAsync <T>(string id) where T : IBaseEntity
{
await GetDBClient();
var result = await _documentClient.DeleteDocumentAsync(UriFactory.CreateDocumentUri(cosmosDBName, typeof(T).Name, id));
return(result.StatusCode == System.Net.HttpStatusCode.Created);
}
public async Task DeleteTodoAsync(string userId, string id)
{
await documentClient.DeleteDocumentAsync(
UriFactory.CreateDocumentUri(dbName, collectionName, id),
new RequestOptions()
{
PartitionKey = new PartitionKey(userId)
});
}
public virtual async Task <IdentityResult> DeleteAsync(TUser user, CancellationToken token)
{
if (UsesPartitioning)
{
await DeleteMapping(user.NormalizedUserName, TypeEnum.UserMappingUsername);
await DeleteMapping(user.NormalizedEmail, TypeEnum.UserMappingEmail);
/*await Task.WhenAll(user.Logins.Select((login) =>
* {
* var partitionKey = login.LoginProvider + login.ProviderKey;
* return DeleteMapping(partitionKey);
* }));*/
}
await _Client.DeleteDocumentAsync(GetUserUri(user), GetRequestOptions(user.PartitionKey));
// todo success based on delete result
return(IdentityResult.Success);
}
//This method is ignored because OpenCover can't cover all branches for async methods
public async Task DeleteDocument(string collectionId, string documentId, RequestOptions options = null)
{
if (options == null)
options = new RequestOptions
{
PartitionKey = new PartitionKey(documentId)
};
var documentUri = UriFactory.CreateDocumentUri(databaseId, collectionId, documentId);
await documentClient.DeleteDocumentAsync(documentUri, options);
}
public virtual async Task Delete(TDocument document)
{
var selfLink = await GetDocumentSelfLink(document);
if (string.IsNullOrWhiteSpace(selfLink))
{
throw new InvalidOperationException("Document does not exist in collection");
}
await _documentClient.DeleteDocumentAsync(selfLink);
}
public async Task <ToDo> DeleteById(Guid id)
{
var deleted = await GetById(id);
if (deleted != null)
{
await _documentClient.DeleteDocumentAsync(GetDocumentUriForEntity(deleted));
}
return(deleted);
}
public async Task DeleteAccount(string email)
{
try
{
await _documentClient.DeleteDocumentAsync(CreateDocumentUri(email),
new RequestOptions { PartitionKey = new PartitionKey("FYP") });
}
catch (DocumentClientException e)
{
throw new StorageErrorException($"Failed to delete account with email {email} from FYP", e, (int)e.StatusCode);
}
}
public async Task SetCompleted()
{
IsCompleted = true;
if (_existing)
{
await _client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(_databaseName, _collectionName, Saga.CorrelationId.ToString()), _requestOptions)
.ConfigureAwait(false);
this.LogRemoved();
}
}
public async Task <Document> DeleteShopAsync(string Id)
{
Document res = null;
try
{
res = await client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(databaseName, collectionName, Id));
}
catch
{
throw new System.Exception($"Shop with id:{Id} was not found");
}
return(res);
}
/// <summary>
/// Deletes a document.
/// </summary>
/// <param name="dbId">Database id.</param>
/// <param name="collectionId">Collection id.</param>
/// <param name="docId">Document id</param>
/// <param name="requestOptions">Request options</param>
/// <returns>Deleted document.</returns>
public async Task <ResourceResponse <Document> > DeleteDocumentAsync(
string dbId, string collectionId, string docId, RequestOptions requestOptions = null)
{
Code.ExpectsNotNullOrWhiteSpaceArgument(dbId, nameof(dbId), TaggingUtilities.ReserveTag(0x2381b1c3 /* tag_961hd */));
Code.ExpectsNotNullOrWhiteSpaceArgument(collectionId, nameof(collectionId), TaggingUtilities.ReserveTag(0x2381b1c4 /* tag_961he */));
Code.ExpectsNotNullOrWhiteSpaceArgument(docId, nameof(docId), TaggingUtilities.ReserveTag(0x2381b1c5 /* tag_961hf */));
IDocumentClient client = await GetDocumentClientAsync().ConfigureAwait(false);
return(await DocumentDbAdapter.ExecuteAndLogAsync(TaggingUtilities.ReserveTag(0x2381b1c6 /* tag_961hg */),
() => client.DeleteDocumentAsync(
UriFactory.CreateDocumentUri(dbId, collectionId, docId), requestOptions))
.ConfigureAwait(false));
}
public async Task SetCompleted()
{
IsCompleted = true;
if (_existing)
{
await _client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(_databaseName, _collectionName, Saga.CorrelationId.ToString())).ConfigureAwait(false);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("SAGA:{0}:{1} Removed {2}", TypeMetadataCache <TSaga> .ShortName, TypeMetadataCache <TMessage> .ShortName, Saga.CorrelationId);
}
}
}
public async Task <IActionResult> Delete(string id)
{
try
{
await _documentClient.DeleteDocumentAsync(
UriFactory.CreateDocumentUri(databaseId, collectionId, id)
);
return(Ok());
}
catch
{
return(NoContent());
}
}
public async Task DeleteAllExportJobRecordsAsync(CancellationToken cancellationToken = default)
{
IDocumentQuery <Document> query = _documentClient.CreateDocumentQuery <Document>(
_collectionUri,
new SqlQuerySpec("SELECT doc._self FROM doc"),
new FeedOptions()
{
PartitionKey = new PartitionKey(ExportJobPartitionKey)
})
.AsDocumentQuery();
while (query.HasMoreResults)
{
FeedResponse <Document> documents = await query.ExecuteNextAsync <Document>(cancellationToken);
foreach (Document doc in documents)
{
await _documentClient.DeleteDocumentAsync(doc.SelfLink, new RequestOptions()
{
PartitionKey = new PartitionKey(ExportJobPartitionKey)
}, cancellationToken);
}
}
}
public async Task Delete(string id)
{
try
{
await _client.DeleteDocumentAsync(UriFactory.CreateDocumentUri(_databaseId, _documentCollection.Id, id));
}
catch (DocumentClientException exception)
{
if (exception.StatusCode == HttpStatusCode.NotFound)
{
return;
}
throw;
}
}
public async Task <bool> RemoveAsync(string id, RequestOptions requestOptions = null)
{
bool isSuccess = false;
var doc = await GetDocumentByIdAsync(id);
if (doc != null)
{
var result = await _client.DeleteDocumentAsync(doc.SelfLink, requestOptions);
isSuccess = result.StatusCode == HttpStatusCode.NoContent;
}
return(isSuccess);
}
/// <summary>
/// Removes the object instance by removing the document from documentdb.
/// WARNING: The document will be hard deleted from the db, not by setting an enddate field.
/// </summary>
/// <param name="collectionName">Name of the collection on which the operation must be performed.</param>
/// <param name="id">The id of the object instance that needs to be deleted forever.</param>
/// <param name="partition">The partition of the object to remove.</param>
public async Task Remove(string collectionName, string id, string partition)
{
try
{
Uri uri = CreateDocumentLink(collectionName, id);
await _client.DeleteDocumentAsync(uri, GetRequestOptions(partition));
}
catch (DocumentClientException documentClientException)
{
if (documentClientException.StatusCode == HttpStatusCode.NotFound)
{
_trace.TraceInformation(ErrorCodes.DBDocumentNotFound, collectionName, id, partition);
}
throw;
}
}
private static async Task <int> DeleteDocumentsInQueryAsync <T>(IDocumentClient client, IDocumentQuery <T> query)
{
var linksToDelete = new List <string>();
while (query.HasMoreResults)
{
var documents = await query.ExecuteNextAsync <Document>().ConfigureAwait(false);
linksToDelete.AddRange(documents.Select(d => d.SelfLink));
}
foreach (var link in linksToDelete)
{
await client.DeleteDocumentAsync(link).ConfigureAwait(false);
}
return(linksToDelete.Count);
}
public static async Task <ResourceResponse <Document> > HandleEntityDeleteAsync(string tableName, string partitionKey, string rowKey, string ifMatch, IDocumentClient client, RequestOptions requestOptions, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
Uri uri = UriFactory.CreateDocumentUri("TablesDB", tableName, rowKey);
requestOptions = SetPartitionKey(requestOptions, partitionKey);
if (!string.IsNullOrEmpty(ifMatch))
{
requestOptions.AccessCondition = new AccessCondition
{
Type = AccessConditionType.IfMatch,
Condition = ifMatch
};
}
return(await client.DeleteDocumentAsync(uri.ToString(), requestOptions));
}
public async Task DeleteMessage(string conversationId, string messageId)
{
try
{
await _documentClient.DeleteDocumentAsync(CreateDocumentUri(messageId),
new RequestOptions { PartitionKey = new PartitionKey("m_" + conversationId) });
}
catch (DocumentClientException e)
{
if (e.StatusCode == HttpStatusCode.NotFound)
{
throw new MessageNotFoundException($"Message with id {messageId} was not found");
}
throw new StorageErrorException($"Failed to delete message {messageId} from conversation {conversationId}",
e, (int)e.StatusCode);
}
}
public async Task DeleteConversation(string username, string conversationId)
{
try
{
await _documentClient.DeleteDocumentAsync(CreateDocumentUri("m_" + conversationId),
new RequestOptions { PartitionKey = new PartitionKey("c_" + username) });
}
catch (DocumentClientException e)
{
if (e.StatusCode == HttpStatusCode.NotFound)
{
throw new ConversationNotFoundException($"Conversation with id {conversationId} was not found");
}
throw new StorageErrorException($"Failed to delete conversation {conversationId} from User {username}",
e, (int)e.StatusCode);
}
}
public async Task <HttpStatusCode> DeleteAsync(Guid documentId)
{
var documentUri = CreateDocumentUri(documentId);
var existingDocument = await GetAsync(f => f.DocumentId == documentId).ConfigureAwait(false);
if (existingDocument == null)
{
return(HttpStatusCode.NotFound);
}
var accessCondition = new AccessCondition {
Condition = existingDocument.Etag, Type = AccessConditionType.IfMatch
};
var partitionKey = new PartitionKey(existingDocument.PartitionKey);
var result = await documentClient.DeleteDocumentAsync(documentUri, new RequestOptions { AccessCondition = accessCondition, PartitionKey = partitionKey }).ConfigureAwait(false);
return(result.StatusCode);
}
